Merge pull request #3856 from sshine/make-python3-default

[Python] Make Python 3 default

2 files changed, 324 insertions, 324 deletions

diff --git a/es-es/python-es.html.markdown b/es-es/python-es.html.markdown
index 2b8f498a..7deec286 100644
--- a/es-es/python-es.html.markdown
+++ b/es-es/python-es.html.markdown
@@ -1,26 +1,25 @@
 ---
-language: python
+language: Python
 contributors:
-    - ["Louie Dinh", "http://ldinh.ca"]
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
 translators:
-    - ["Camilo Garrido", "http://www.twitter.com/hirohope"]
-    - ["Fabio Souto", "http://fabiosouto.me"]
+    - ["Camilo Garrido", "http://twitter.com/hirohope"]
 lang: es-es
 filename: learnpython-es.py
 ---
 
-Python fue creado por Guido Van Rossum en el principio de los 90. Ahora es uno
-de los lenguajes más populares que existen. Me enamoré de Python por su claridad sintáctica.
+Python fue creado por Guido Van Rossum en el principio de los 90'. Ahora es uno
+de los lenguajes más populares en existencia. Me enamoré de Python por su claridad sintáctica.
 Es básicamente pseudocódigo ejecutable.
 
 ¡Comentarios serán muy apreciados! Pueden contactarme en [@louiedinh](http://twitter.com/louiedinh) o louiedinh [at] [servicio de email de google]
 
-Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser aplicable a Python 2.x. ¡Pronto un recorrido por Python 3!
-
 ```python
+
 # Comentarios de una línea comienzan con una almohadilla (o signo gato)
-""" Strings multilínea pueden escribirse
-    usando tres "'s, y comúnmente son usados
+
+""" Strings multilinea pueden escribirse
+    usando tres "'s, y comunmente son usados
     como comentarios.
 """
 
@@ -31,69 +30,49 @@ Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser apl
 # Tienes números
 3 #=> 3
 
-# Evidentemente puedes realizar operaciones matemáticas
-1 + 1  #=> 2
-8 - 1  #=> 7
-10 * 2  #=> 20
-35 / 5  #=> 7
-
-# La división es un poco complicada. Es división entera y toma la parte entera
-# de los resultados automáticamente.
-5 / 2  #=> 2
+# Matemática es lo que esperarías
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
 
-# Para arreglar la división necesitamos aprender sobre 'floats'
-# (números de coma flotante).
-2.0     # Esto es un 'float'
-11.0 / 4.0  #=> 2.75 ahhh...mucho mejor
+# Excepto la división la cual por defecto retorna un número 'float' (número de coma flotante)
+35 / 5  # => 7.0
+# Sin embargo también tienes disponible división entera
+34 // 5 # => 6
 
-# Resultado de la división de enteros truncada para positivos y negativos
-5 // 3     # => 1
-5.0 // 3.0 # => 1.0 # funciona con números de coma flotante
--5 // 3  # => -2
--5.0 // 3.0 # => -2.0
-
-# El operador módulo devuelve el resto de una división entre enteros
-7 % 3 # => 1
-
-# Exponenciación (x elevado a y)
-2**4 # => 16
+# Cuando usas un float, los resultados son floats
+3 * 2.0 # => 6.0
 
 # Refuerza la precedencia con paréntesis
-(1 + 3) * 2  #=> 8
+(1 + 3) * 2  # => 8
 
-# Operadores booleanos
-# Nota: "and" y "or" son sensibles a mayúsculas
-True and False #=> False
-False or True #=> True
 
-# Podemos usar operadores booleanos con números enteros
-0 and 2 #=> 0
--5 or 0 #=> -5
-0 == False #=> True
-2 == True #=> False
-1 == True #=> True
+# Valores 'boolean' (booleanos) son primitivos
+True
+False
 
 # Niega con 'not'
-not True #=> False
-not False #=> True
+not True  # => False
+not False  # => True
+
 
 # Igualdad es ==
-1 == 1 #=> True
-2 == 1 #=> False
+1 == 1  # => True
+2 == 1  # => False
 
 # Desigualdad es !=
-1 != 1 #=> False
-2 != 1 #=> True
+1 != 1  # => False
+2 != 1  # => True
 
 # Más comparaciones
-1 < 10 #=> True
-1 > 10 #=> False
-2 <= 2 #=> True
-2 >= 2 #=> True
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
 
 # ¡Las comparaciones pueden ser concatenadas!
-1 < 2 < 3 #=> True
-2 < 3 < 2 #=> False
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
 
 # Strings se crean con " o '
 "Esto es un string."
@@ -105,40 +84,41 @@ not False #=> True
 # Un string puede ser tratado como una lista de caracteres
 "Esto es un string"[0] #=> 'E'
 
-# % pueden ser usados para formatear strings, como esto:
-"%s pueden ser %s" % ("strings", "interpolados")
+# .format puede ser usaro para darle formato a los strings, así:
+"{} pueden ser {}".format("strings", "interpolados")
 
-# Una forma más reciente de formatear strings es el método 'format'.
-# Este método es la forma preferida
-"{0} pueden ser {1}".format("strings", "formateados")
-# Puedes usar palabras clave si no quieres contar.
-"{nombre} quiere comer {comida}".format(nombre="Bob", comida="lasaña")
+# Puedes reutilizar los argumentos de formato si estos se repiten.
+"{0} sé ligero, {0} sé rápido, {0} brinca sobre la {1}".format("Jack", "vela") #=> "Jack sé ligero, Jack sé rápido, Jack brinca sobre la vela"
+# Puedes usar palabras claves si no quieres contar.
+"{nombre} quiere comer {comida}".format(nombre="Bob", comida="lasaña") #=> "Bob quiere comer lasaña"
+# También puedes interpolar cadenas usando variables en el contexto
+nombre = 'Bob'
+comida = 'Lasaña'
+f'{nombre} quiere comer {comida}'  #=> "Bob quiere comer lasaña"
 
 # None es un objeto
-None #=> None
+None  # => None
 
 # No uses el símbolo de igualdad `==` para comparar objetos con None
-# Usa `is` en lugar de
+# Usa `is` en su lugar
 "etc" is None #=> False
 None is None  #=> True
 
-# El operador 'is' prueba la identidad del objeto. Esto no es
-# muy útil cuando se trata de datos primitivos, pero es
-# muy útil cuando se trata de objetos.
-
-# None, 0, y strings/listas vacíos(as) todas se evalúan como False.
+# None, 0, y strings/listas/diccionarios/conjuntos vacíos(as) todos se evalúan como False.
 # Todos los otros valores son True
-bool(0) #=> False
-bool("") #=> False
+bool(0)  # => False
+bool("")  # => False
+bool([]) #=> False
+bool({}) #=> False
+bool(set()) #=> False
 
 
 ####################################################
 ## 2. Variables y Colecciones
 ####################################################
 
-# Imprimir es muy fácil
-print "Soy Python. ¡Encantado de conocerte!"
-
+# Python tiene una función para imprimir
+print("Soy Python. Encantado de conocerte")
 
 # No hay necesidad de declarar las variables antes de asignarlas.
 una_variable = 5    # La convención es usar guiones_bajos_con_minúsculas
@@ -148,19 +128,16 @@ una_variable #=> 5
 # Ve Control de Flujo para aprender más sobre el manejo de excepciones.
 otra_variable  # Levanta un error de nombre
 
-# 'if' puede ser usado como una expresión
-"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
-
-# Las listas almacenan secuencias
+# Listas almacena secuencias
 lista = []
 # Puedes empezar con una lista prellenada
 otra_lista = [4, 5, 6]
 
 # Añadir cosas al final de una lista con 'append'
-lista.append(1)    # lista ahora es [1]
-lista.append(2)    # lista ahora es [1, 2]
-lista.append(4)    # lista ahora es [1, 2, 4]
-lista.append(3)    # lista ahora es [1, 2, 4, 3]
+lista.append(1)    #lista ahora es [1]
+lista.append(2)    #lista ahora es [1, 2]
+lista.append(4)    #lista ahora es [1, 2, 4]
+lista.append(3)    #lista ahora es [1, 2, 4, 3]
 # Remueve del final de la lista con 'pop'
 lista.pop()        #=> 3 y lista ahora es [1, 2, 4]
 # Pongámoslo de vuelta
@@ -181,6 +158,12 @@ lista[1:3] #=> [2, 4]
 lista[2:] #=> [4, 3]
 # Omite el final
 lista[:3] #=> [1, 2, 4]
+# Selecciona cada dos elementos
+lista[::2]   # =>[1, 4]
+# Invierte la lista
+lista[::-1]   # => [3, 4, 2, 1]
+# Usa cualquier combinación de estos para crear trozos avanzados
+# lista[inicio:final:pasos]
 
 # Remueve elementos arbitrarios de una lista con 'del'
 del lista[2] # lista ahora es [1, 2, 3]
@@ -191,14 +174,14 @@ lista + otra_lista #=> [1, 2, 3, 4, 5, 6] - Nota: lista y otra_lista no se tocan
 # Concatenar listas con 'extend'
 lista.extend(otra_lista) # lista ahora es [1, 2, 3, 4, 5, 6]
 
-# Chequea la existencia en una lista con
+# Verifica la existencia en una lista con 'in'
 1 in lista #=> True
 
-# Examina el tamaño de una lista con 'len'
+# Examina el largo de una lista con 'len'
 len(lista) #=> 6
 
 
-# Las tuplas son como las listas, pero son inmutables.
+# Tuplas son como listas pero son inmutables.
 tupla = (1, 2, 3)
 tupla[0] #=> 1
 tupla[0] = 3  # Levanta un error TypeError
@@ -217,7 +200,7 @@ d, e, f = 4, 5, 6
 e, d = d, e     # d ahora es 5 y e ahora es 4
 
 
-# Diccionarios almacenan mapeos
+# Diccionarios relacionan llaves y valores
 dicc_vacio = {}
 # Aquí está un diccionario prellenado
 dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
@@ -225,16 +208,16 @@ dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
 # Busca valores con []
 dicc_lleno["uno"] #=> 1
 
-# Obtén todas las llaves como una lista
-dicc_lleno.keys() #=> ["tres", "dos", "uno"]
+# Obtén todas las llaves como una lista con 'keys()'. Necesitamos envolver la llamada en 'list()' porque obtenemos un iterable. Hablaremos de eso luego.
+list(dicc_lleno.keys()) #=> ["tres", "dos", "uno"]
 # Nota - El orden de las llaves del diccionario no está garantizada.
 # Tus resultados podrían no ser los mismos del ejemplo.
 
-# Obtén todos los valores como una lista
-dicc_lleno.values() #=> [3, 2, 1]
+# Obtén todos los valores como una lista. Nuevamente necesitamos envolverlas en una lista para sacarlas del iterable.
+list(dicc_lleno.values()) #=> [3, 2, 1]
 # Nota - Lo mismo que con las llaves, no se garantiza el orden.
 
-# Chequea la existencia de una llave en el diccionario con 'in'
+# Verifica la existencia de una llave en el diccionario con 'in'
 "uno" in dicc_lleno #=> True
 1 in dicc_lleno #=> False
 
@@ -248,19 +231,18 @@ dicc_lleno.get("cuatro") #=> None
 dicc_lleno.get("uno", 4) #=> 1
 dicc_lleno.get("cuatro", 4) #=> 4
 
-# El método 'setdefault' es una manera segura de añadir nuevos pares
-# llave-valor en un diccionario
+# El método 'setdefault' inserta en un diccionario solo si la llave no está presente
 dicc_lleno.setdefault("cinco", 5) #dicc_lleno["cinco"] es puesto con valor 5
 dicc_lleno.setdefault("cinco", 6) #dicc_lleno["cinco"] todavía es 5
 
 
+# Remueve llaves de un diccionario con 'del'
+del dicc_lleno['uno'] # Remueve la llave 'uno' de dicc_lleno
+
 # Sets (conjuntos) almacenan ... bueno, conjuntos
 conjunto_vacio = set()
-# Inicializar un conjunto con montón de valores
-un_conjunto = set([1,2,2,3,4]) # un_conjunto ahora es set([1, 2, 3, 4])
-
-# Desde Python 2.7, {} puede ser usado para declarar un conjunto
-conjunto_lleno = {1, 2, 2, 3, 4} # => {1 2 3 4}
+# Inicializar un conjunto con montón de valores. Yeah, se ve un poco como un diccionario. Lo siento.
+un_conjunto = {1,2,2,3,4} # un_conjunto ahora es {1, 2, 3, 4}
 
 # Añade más valores a un conjunto
 conjunto_lleno.add(5) # conjunto_lleno ahora es {1, 2, 3, 4, 5}
@@ -275,7 +257,7 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
 # Haz diferencia de conjuntos con -
 {1,2,3,4} - {2,3,5} #=> {1, 4}
 
-# Chequea la existencia en un conjunto con 'in'
+# Verifica la existencia en un conjunto con 'in'
 2 in conjunto_lleno #=> True
 10 in conjunto_lleno #=> False
 
@@ -284,32 +266,30 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
 ## 3. Control de Flujo
 ####################################################
 
-# Hagamos sólo una variable
-una_variable = 5
+# Creemos una variable para experimentar
+some_var = 5
 
-# Aquí está una declaración de un 'if'. ¡La indentación es importante en Python!
+# Aquí está una declaración de un 'if'. ¡La indentación es significativa en Python!
 # imprime "una_variable es menor que 10"
 if una_variable > 10:
-    print "una_variable es completamente mas grande que 10."
+    print("una_variable es completamente mas grande que 10.")
 elif una_variable < 10:    # Este condición 'elif' es opcional.
-    print "una_variable es mas chica que 10."
+    print("una_variable es mas chica que 10.")
 else:           # Esto también es opcional.
-    print "una_variable es de hecho 10."
-
+    print("una_variable es de hecho 10.")
 
 """
-For itera sobre listas
+For itera sobre iterables (listas, cadenas, diccionarios, tuplas, generadores...)
 imprime:
     perro es un mamifero
     gato es un mamifero
     raton es un mamifero
 """
 for animal in ["perro", "gato", "raton"]:
-    # Puedes usar % para interpolar strings formateados
-    print "%s es un mamifero" % animal
+    print("{} es un mamifero".format(animal))
 
 """
-`range(número)` retorna una lista de números
+`range(número)` retorna un generador de números
 desde cero hasta el número dado
 imprime:
     0
@@ -318,7 +298,7 @@ imprime:
     3
 """
 for i in range(4):
-    print i
+    print(i)
 
 """
 While itera hasta que una condición no se cumple.
@@ -330,18 +310,49 @@ imprime:
 """
 x = 0
 while x < 4:
-    print x
+    print(x)
     x += 1  # versión corta de x = x + 1
 
 # Maneja excepciones con un bloque try/except
-
-# Funciona desde Python 2.6 en adelante:
 try:
     # Usa raise para levantar un error
     raise IndexError("Este es un error de indice")
 except IndexError as e:
     pass    # Pass no hace nada. Usualmente harias alguna recuperacion aqui.
 
+# Python oferce una abstracción fundamental llamada Iterable.
+# Un iterable es un objeto que puede ser tratado como una sequencia.
+# El objeto es retornado por la función 'range' es un iterable.
+
+dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
+nuestro_iterable = dicc_lleno.keys()
+print(nuestro_iterable) #=> dict_keys(['uno', 'dos', 'tres']). Este es un objeto que implementa nuestra interfaz Iterable
+
+Podemos recorrerla.
+for i in nuestro_iterable:
+    print(i)    # Imprime uno, dos, tres
+
+# Aunque no podemos selecionar un elemento por su índice.
+nuestro_iterable[1]  # Genera un TypeError
+
+# Un iterable es un objeto que sabe como crear un iterador.
+nuestro_iterator = iter(nuestro_iterable)
+
+# Nuestro iterador es un objeto que puede recordar el estado mientras lo recorremos.
+# Obtenemos el siguiente objeto llamando la función __next__.
+nuestro_iterator.__next__()  #=> "uno"
+
+# Mantiene el estado mientras llamamos __next__.
+nuestro_iterator.__next__()  #=> "dos"
+nuestro_iterator.__next__()  #=> "tres"
+
+# Después que el iterador ha retornado todos sus datos, da una excepción StopIterator.
+nuestro_iterator.__next__() # Genera StopIteration
+
+# Puedes obtener todos los elementos de un iterador llamando a list() en el.
+list(dicc_lleno.keys())  #=> Retorna ["uno", "dos", "tres"]
+
+
 
 ####################################################
 ## 4. Funciones
@@ -349,7 +360,7 @@ except IndexError as e:
 
 # Usa 'def' para crear nuevas funciones
 def add(x, y):
-    print "x es %s y y es %s" % (x, y)
+    print("x es {} y y es {}".format(x, y))
     return x + y    # Retorna valores con una la declaración return
 
 # Llamando funciones con parámetros
@@ -358,6 +369,7 @@ add(5, 6) #=> imprime "x es 5 y y es 6" y retorna 11
 # Otra forma de llamar funciones es con argumentos de palabras claves
 add(y=6, x=5)   # Argumentos de palabra clave pueden ir en cualquier orden.
 
+
 # Puedes definir funciones que tomen un número variable de argumentos
 def varargs(*args):
     return args
@@ -373,6 +385,7 @@ def keyword_args(**kwargs):
 # Llamémosla para ver que sucede
 keyword_args(pie="grande", lago="ness") #=> {"pie": "grande", "lago": "ness"}
 
+
 # Puedes hacer ambas a la vez si quieres
 def todos_los_argumentos(*args, **kwargs):
     print args
@@ -410,23 +423,28 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
 # Podemos usar listas por comprensión para mapeos y filtros agradables
 [add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
 [x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+# también hay diccionarios
+{k:k**2 for k in range(3)} #=> {0: 0, 1: 1, 2: 4}
+# y conjuntos por comprensión
+{c for c in "la cadena"} #=> {'d', 'l', 'a', 'n', ' ', 'c', 'e'}
 
 ####################################################
-## 5. Clases
+## 5. Classes
 ####################################################
 
+
 # Heredamos de object para obtener una clase.
 class Humano(object):
 
     # Un atributo de clase es compartido por todas las instancias de esta clase
     especie = "H. sapiens"
 
-    # Constructor básico, se llama al instanciar la clase.
+    # Constructor basico
     def __init__(self, nombre):
         # Asigna el argumento al atributo nombre de la instancia
         self.nombre = nombre
 
-    # Un método de instancia. Todos los metodos toman self como primer argumento
+    # Un metodo de instancia. Todos los metodos toman self como primer argumento
     def decir(self, msg):
        return "%s: %s" % (self.nombre, msg)
 
@@ -436,7 +454,7 @@ class Humano(object):
     def get_especie(cls):
         return cls.especie
 
-    # Un metodo estático es llamado sin la clase o instancia como referencia
+    # Un metodo estatico es llamado sin la clase o instancia como referencia
     @staticmethod
     def roncar():
         return "*roncar*"
@@ -467,12 +485,12 @@ Humano.roncar() #=> "*roncar*"
 
 # Puedes importar módulos
 import math
-print math.sqrt(16) #=> 4.0
+print(math.sqrt(16)) #=> 4.0
 
 # Puedes obtener funciones específicas desde un módulo
 from math import ceil, floor
-print ceil(3.7)  #=> 4.0
-print floor(3.7) #=> 3.0
+print(ceil(3.7)) #=> 4.0
+print(floor(3.7))#=> 3.0
 
 # Puedes importar todas las funciones de un módulo
 # Precaución: Esto no es recomendable
@@ -495,52 +513,48 @@ dir(math)
 ## 7. Avanzado
 ####################################################
 
-# Los generadores permiten evaluación perezosa
+# Los generadores te ayudan a hacer un código perezoso (lazy)
 def duplicar_numeros(iterable):
     for i in iterable:
         yield i + i
 
-# Un generador crea valores sobre la marcha
-# En vez de generar y devolver todos los valores de una vez, crea un valor
-# en cada iteración. En este ejemplo los valores mayores que 15 no serán 
-# procesados en duplicar_numeros.
-# Nota: xrange es un generador que hace lo mismo que range.
-# Crear una lista de 1 a 900000000 lleva mucho tiempo y ocupa mucho espacio.
-# xrange crea un generador, mientras que range crea toda la lista.
-# Añadimos un guión bajo a los nombres de variable que coinciden con palabras
-# reservadas de python.
-xrange_ = xrange(1, 900000000)
-
-# duplica todos los números hasta que encuentra un resultado >= 30
-for i in duplicar_numeros(xrange_):
-    print i
+# Un generador crea valores sobre la marcha.
+# En vez de generar y retornar todos los valores de una vez, crea uno en cada iteración.
+# Esto significa que valores más grandes que 15 no serán procesados en 'duplicar_numeros'.
+# Fíjate que 'range' es un generador. Crear una lista 1-900000000 tomaría mucho tiempo en crearse.
+_rango = range(1, 900000000)
+# Duplicará todos los números hasta que un resultado >= se encuentre.
+for i in duplicar_numeros(_rango):
+    print(i)
     if i >= 30:
         break
 
+
 # Decoradores
-# en este ejemplo pedir rodea a hablar
-# Si por_favor es True se cambiará el mensaje.
+# en este ejemplo 'pedir' envuelve a 'decir'
+# Pedir llamará a 'decir'. Si decir_por_favor es True entonces cambiará el mensaje a retornar
 from functools import wraps
 
 
-def pedir(target_function):
-    @wraps(target_function)
+def pedir(_decir):
+    @wraps(_decir)
     def wrapper(*args, **kwargs):
-        msg, por_favor = target_function(*args, **kwargs)
-        if por_favor:
-            return "{} {}".format(msg, "¡Por favor! Soy pobre :(")
-        return msg
+        mensaje, decir_por_favor = _decir(*args, **kwargs)
+        if decir_por_favor:
+            return "{} {}".format(mensaje, "¡Por favor! Soy pobre :(")
+        return mensaje
 
     return wrapper
 
 
 @pedir
-def hablar(por_favor=False):
-    msg = "¿Me puedes comprar una cerveza?"
-    return msg, por_favor
+def say(decir_por_favor=False):
+    mensaje = "¿Puedes comprarme una cerveza?"
+    return mensaje, decir_por_favor
+
 
-print hablar()  # ¿Me puedes comprar una cerveza?
-print hablar(por_favor=True)  # ¿Me puedes comprar una cerveza? ¡Por favor! Soy pobre :(
+print(decir())  # ¿Puedes comprarme una cerveza?
+print(decir(decir_por_favor=True))  # ¿Puedes comprarme una cerveza? ¡Por favor! Soy pobre :()
 ```
 
 ## ¿Listo para más?
@@ -549,9 +563,10 @@ print hablar(por_favor=True)  # ¿Me puedes comprar una cerveza? ¡Por favor! So
 
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
 * [Dive Into Python](http://www.diveintopython.net/)
-* [The Official Docs](http://docs.python.org/2.6/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
 * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [Python Module of the Week](http://pymotw.com/2/)
+* [Python Module of the Week](http://pymotw.com/3/)
 * [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
 
 ### Encuadernados
diff --git a/es-es/python3-es.html.markdown b/es-es/pythonlegacy-es.html.markdown
index 3236e73a..0a7304e9 100644
--- a/es-es/python3-es.html.markdown
+++ b/es-es/pythonlegacy-es.html.markdown
@@ -1,25 +1,26 @@
 ---
-language: python3
+language: Python 2 (legacy)
 contributors:
-    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Louie Dinh", "http://ldinh.ca"]
 translators:
-    - ["Camilo Garrido", "http://twitter.com/hirohope"]
+    - ["Camilo Garrido", "http://www.twitter.com/hirohope"]
+    - ["Fabio Souto", "http://fabiosouto.me"]
 lang: es-es
-filename: learnpython3-es.py
+filename: learnpythonlegacy-es.py
 ---
 
-Python fue creado por Guido Van Rossum en el principio de los 90'. Ahora es uno
-de los lenguajes más populares en existencia. Me enamoré de Python por su claridad sintáctica.
+Python fue creado por Guido Van Rossum en el principio de los 90. Ahora es uno
+de los lenguajes más populares que existen. Me enamoré de Python por su claridad sintáctica.
 Es básicamente pseudocódigo ejecutable.
 
 ¡Comentarios serán muy apreciados! Pueden contactarme en [@louiedinh](http://twitter.com/louiedinh) o louiedinh [at] [servicio de email de google]
 
-```python
+Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser aplicable a Python 2.x. ¡Pronto un recorrido por Python 3!
 
+```python
 # Comentarios de una línea comienzan con una almohadilla (o signo gato)
-
-""" Strings multilinea pueden escribirse
-    usando tres "'s, y comunmente son usados
+""" Strings multilínea pueden escribirse
+    usando tres "'s, y comúnmente son usados
     como comentarios.
 """
 
@@ -30,49 +31,69 @@ Es básicamente pseudocódigo ejecutable.
 # Tienes números
 3 #=> 3
 
-# Matemática es lo que esperarías
-1 + 1 #=> 2
-8 - 1 #=> 7
-10 * 2 #=> 20
+# Evidentemente puedes realizar operaciones matemáticas
+1 + 1  #=> 2
+8 - 1  #=> 7
+10 * 2  #=> 20
+35 / 5  #=> 7
+
+# La división es un poco complicada. Es división entera y toma la parte entera
+# de los resultados automáticamente.
+5 / 2  #=> 2
 
-# Excepto la división la cual por defecto retorna un número 'float' (número de coma flotante)
-35 / 5  # => 7.0
-# Sin embargo también tienes disponible división entera
-34 // 5 # => 6
+# Para arreglar la división necesitamos aprender sobre 'floats'
+# (números de coma flotante).
+2.0     # Esto es un 'float'
+11.0 / 4.0  #=> 2.75 ahhh...mucho mejor
 
-# Cuando usas un float, los resultados son floats
-3 * 2.0 # => 6.0
+# Resultado de la división de enteros truncada para positivos y negativos
+5 // 3     # => 1
+5.0 // 3.0 # => 1.0 # funciona con números de coma flotante
+-5 // 3  # => -2
+-5.0 // 3.0 # => -2.0
+
+# El operador módulo devuelve el resto de una división entre enteros
+7 % 3 # => 1
+
+# Exponenciación (x elevado a y)
+2**4 # => 16
 
 # Refuerza la precedencia con paréntesis
-(1 + 3) * 2  # => 8
+(1 + 3) * 2  #=> 8
 
+# Operadores booleanos
+# Nota: "and" y "or" son sensibles a mayúsculas
+True and False #=> False
+False or True #=> True
 
-# Valores 'boolean' (booleanos) son primitivos
-True
-False
+# Podemos usar operadores booleanos con números enteros
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+1 == True #=> True
 
 # Niega con 'not'
-not True  # => False
-not False  # => True
-
+not True #=> False
+not False #=> True
 
 # Igualdad es ==
-1 == 1  # => True
-2 == 1  # => False
+1 == 1 #=> True
+2 == 1 #=> False
 
 # Desigualdad es !=
-1 != 1  # => False
-2 != 1  # => True
+1 != 1 #=> False
+2 != 1 #=> True
 
 # Más comparaciones
-1 < 10  # => True
-1 > 10  # => False
-2 <= 2  # => True
-2 >= 2  # => True
+1 < 10 #=> True
+1 > 10 #=> False
+2 <= 2 #=> True
+2 >= 2 #=> True
 
 # ¡Las comparaciones pueden ser concatenadas!
-1 < 2 < 3  # => True
-2 < 3 < 2  # => False
+1 < 2 < 3 #=> True
+2 < 3 < 2 #=> False
 
 # Strings se crean con " o '
 "Esto es un string."
@@ -84,41 +105,40 @@ not False  # => True
 # Un string puede ser tratado como una lista de caracteres
 "Esto es un string"[0] #=> 'E'
 
-# .format puede ser usaro para darle formato a los strings, así:
-"{} pueden ser {}".format("strings", "interpolados")
+# % pueden ser usados para formatear strings, como esto:
+"%s pueden ser %s" % ("strings", "interpolados")
 
-# Puedes reutilizar los argumentos de formato si estos se repiten.
-"{0} sé ligero, {0} sé rápido, {0} brinca sobre la {1}".format("Jack", "vela") #=> "Jack sé ligero, Jack sé rápido, Jack brinca sobre la vela"
-# Puedes usar palabras claves si no quieres contar.
-"{nombre} quiere comer {comida}".format(nombre="Bob", comida="lasaña") #=> "Bob quiere comer lasaña"
-# También puedes interpolar cadenas usando variables en el contexto
-nombre = 'Bob'
-comida = 'Lasaña'
-f'{nombre} quiere comer {comida}'  #=> "Bob quiere comer lasaña"
+# Una forma más reciente de formatear strings es el método 'format'.
+# Este método es la forma preferida
+"{0} pueden ser {1}".format("strings", "formateados")
+# Puedes usar palabras clave si no quieres contar.
+"{nombre} quiere comer {comida}".format(nombre="Bob", comida="lasaña")
 
 # None es un objeto
-None  # => None
+None #=> None
 
 # No uses el símbolo de igualdad `==` para comparar objetos con None
-# Usa `is` en su lugar
+# Usa `is` en lugar de
 "etc" is None #=> False
 None is None  #=> True
 
-# None, 0, y strings/listas/diccionarios/conjuntos vacíos(as) todos se evalúan como False.
+# El operador 'is' prueba la identidad del objeto. Esto no es
+# muy útil cuando se trata de datos primitivos, pero es
+# muy útil cuando se trata de objetos.
+
+# None, 0, y strings/listas vacíos(as) todas se evalúan como False.
 # Todos los otros valores son True
-bool(0)  # => False
-bool("")  # => False
-bool([]) #=> False
-bool({}) #=> False
-bool(set()) #=> False
+bool(0) #=> False
+bool("") #=> False
 
 
 ####################################################
 ## 2. Variables y Colecciones
 ####################################################
 
-# Python tiene una función para imprimir
-print("Soy Python. Encantado de conocerte")
+# Imprimir es muy fácil
+print "Soy Python. ¡Encantado de conocerte!"
+
 
 # No hay necesidad de declarar las variables antes de asignarlas.
 una_variable = 5    # La convención es usar guiones_bajos_con_minúsculas
@@ -128,16 +148,19 @@ una_variable #=> 5
 # Ve Control de Flujo para aprender más sobre el manejo de excepciones.
 otra_variable  # Levanta un error de nombre
 
-# Listas almacena secuencias
+# 'if' puede ser usado como una expresión
+"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
+
+# Las listas almacenan secuencias
 lista = []
 # Puedes empezar con una lista prellenada
 otra_lista = [4, 5, 6]
 
 # Añadir cosas al final de una lista con 'append'
-lista.append(1)    #lista ahora es [1]
-lista.append(2)    #lista ahora es [1, 2]
-lista.append(4)    #lista ahora es [1, 2, 4]
-lista.append(3)    #lista ahora es [1, 2, 4, 3]
+lista.append(1)    # lista ahora es [1]
+lista.append(2)    # lista ahora es [1, 2]
+lista.append(4)    # lista ahora es [1, 2, 4]
+lista.append(3)    # lista ahora es [1, 2, 4, 3]
 # Remueve del final de la lista con 'pop'
 lista.pop()        #=> 3 y lista ahora es [1, 2, 4]
 # Pongámoslo de vuelta
@@ -158,12 +181,6 @@ lista[1:3] #=> [2, 4]
 lista[2:] #=> [4, 3]
 # Omite el final
 lista[:3] #=> [1, 2, 4]
-# Selecciona cada dos elementos
-lista[::2]   # =>[1, 4]
-# Invierte la lista
-lista[::-1]   # => [3, 4, 2, 1]
-# Usa cualquier combinación de estos para crear trozos avanzados
-# lista[inicio:final:pasos]
 
 # Remueve elementos arbitrarios de una lista con 'del'
 del lista[2] # lista ahora es [1, 2, 3]
@@ -174,14 +191,14 @@ lista + otra_lista #=> [1, 2, 3, 4, 5, 6] - Nota: lista y otra_lista no se tocan
 # Concatenar listas con 'extend'
 lista.extend(otra_lista) # lista ahora es [1, 2, 3, 4, 5, 6]
 
-# Verifica la existencia en una lista con 'in'
+# Chequea la existencia en una lista con
 1 in lista #=> True
 
-# Examina el largo de una lista con 'len'
+# Examina el tamaño de una lista con 'len'
 len(lista) #=> 6
 
 
-# Tuplas son como listas pero son inmutables.
+# Las tuplas son como las listas, pero son inmutables.
 tupla = (1, 2, 3)
 tupla[0] #=> 1
 tupla[0] = 3  # Levanta un error TypeError
@@ -200,7 +217,7 @@ d, e, f = 4, 5, 6
 e, d = d, e     # d ahora es 5 y e ahora es 4
 
 
-# Diccionarios relacionan llaves y valores
+# Diccionarios almacenan mapeos
 dicc_vacio = {}
 # Aquí está un diccionario prellenado
 dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
@@ -208,16 +225,16 @@ dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
 # Busca valores con []
 dicc_lleno["uno"] #=> 1
 
-# Obtén todas las llaves como una lista con 'keys()'. Necesitamos envolver la llamada en 'list()' porque obtenemos un iterable. Hablaremos de eso luego.
-list(dicc_lleno.keys()) #=> ["tres", "dos", "uno"]
+# Obtén todas las llaves como una lista
+dicc_lleno.keys() #=> ["tres", "dos", "uno"]
 # Nota - El orden de las llaves del diccionario no está garantizada.
 # Tus resultados podrían no ser los mismos del ejemplo.
 
-# Obtén todos los valores como una lista. Nuevamente necesitamos envolverlas en una lista para sacarlas del iterable.
-list(dicc_lleno.values()) #=> [3, 2, 1]
+# Obtén todos los valores como una lista
+dicc_lleno.values() #=> [3, 2, 1]
 # Nota - Lo mismo que con las llaves, no se garantiza el orden.
 
-# Verifica la existencia de una llave en el diccionario con 'in'
+# Chequea la existencia de una llave en el diccionario con 'in'
 "uno" in dicc_lleno #=> True
 1 in dicc_lleno #=> False
 
@@ -231,18 +248,19 @@ dicc_lleno.get("cuatro") #=> None
 dicc_lleno.get("uno", 4) #=> 1
 dicc_lleno.get("cuatro", 4) #=> 4
 
-# El método 'setdefault' inserta en un diccionario solo si la llave no está presente
+# El método 'setdefault' es una manera segura de añadir nuevos pares
+# llave-valor en un diccionario
 dicc_lleno.setdefault("cinco", 5) #dicc_lleno["cinco"] es puesto con valor 5
 dicc_lleno.setdefault("cinco", 6) #dicc_lleno["cinco"] todavía es 5
 
 
-# Remueve llaves de un diccionario con 'del'
-del dicc_lleno['uno'] # Remueve la llave 'uno' de dicc_lleno
-
 # Sets (conjuntos) almacenan ... bueno, conjuntos
 conjunto_vacio = set()
-# Inicializar un conjunto con montón de valores. Yeah, se ve un poco como un diccionario. Lo siento.
-un_conjunto = {1,2,2,3,4} # un_conjunto ahora es {1, 2, 3, 4}
+# Inicializar un conjunto con montón de valores
+un_conjunto = set([1,2,2,3,4]) # un_conjunto ahora es set([1, 2, 3, 4])
+
+# Desde Python 2.7, {} puede ser usado para declarar un conjunto
+conjunto_lleno = {1, 2, 2, 3, 4} # => {1 2 3 4}
 
 # Añade más valores a un conjunto
 conjunto_lleno.add(5) # conjunto_lleno ahora es {1, 2, 3, 4, 5}
@@ -257,7 +275,7 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
 # Haz diferencia de conjuntos con -
 {1,2,3,4} - {2,3,5} #=> {1, 4}
 
-# Verifica la existencia en un conjunto con 'in'
+# Chequea la existencia en un conjunto con 'in'
 2 in conjunto_lleno #=> True
 10 in conjunto_lleno #=> False
 
@@ -266,30 +284,32 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
 ## 3. Control de Flujo
 ####################################################
 
-# Creemos una variable para experimentar
-some_var = 5
+# Hagamos sólo una variable
+una_variable = 5
 
-# Aquí está una declaración de un 'if'. ¡La indentación es significativa en Python!
+# Aquí está una declaración de un 'if'. ¡La indentación es importante en Python!
 # imprime "una_variable es menor que 10"
 if una_variable > 10:
-    print("una_variable es completamente mas grande que 10.")
+    print "una_variable es completamente mas grande que 10."
 elif una_variable < 10:    # Este condición 'elif' es opcional.
-    print("una_variable es mas chica que 10.")
+    print "una_variable es mas chica que 10."
 else:           # Esto también es opcional.
-    print("una_variable es de hecho 10.")
+    print "una_variable es de hecho 10."
+
 
 """
-For itera sobre iterables (listas, cadenas, diccionarios, tuplas, generadores...)
+For itera sobre listas
 imprime:
     perro es un mamifero
     gato es un mamifero
     raton es un mamifero
 """
 for animal in ["perro", "gato", "raton"]:
-    print("{} es un mamifero".format(animal))
+    # Puedes usar % para interpolar strings formateados
+    print "%s es un mamifero" % animal
 
 """
-`range(número)` retorna un generador de números
+`range(número)` retorna una lista de números
 desde cero hasta el número dado
 imprime:
     0
@@ -298,7 +318,7 @@ imprime:
     3
 """
 for i in range(4):
-    print(i)
+    print i
 
 """
 While itera hasta que una condición no se cumple.
@@ -310,49 +330,18 @@ imprime:
 """
 x = 0
 while x < 4:
-    print(x)
+    print x
     x += 1  # versión corta de x = x + 1
 
 # Maneja excepciones con un bloque try/except
+
+# Funciona desde Python 2.6 en adelante:
 try:
     # Usa raise para levantar un error
     raise IndexError("Este es un error de indice")
 except IndexError as e:
     pass    # Pass no hace nada. Usualmente harias alguna recuperacion aqui.
 
-# Python oferce una abstracción fundamental llamada Iterable.
-# Un iterable es un objeto que puede ser tratado como una sequencia.
-# El objeto es retornado por la función 'range' es un iterable.
-
-dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
-nuestro_iterable = dicc_lleno.keys()
-print(nuestro_iterable) #=> dict_keys(['uno', 'dos', 'tres']). Este es un objeto que implementa nuestra interfaz Iterable
-
-Podemos recorrerla.
-for i in nuestro_iterable:
-    print(i)    # Imprime uno, dos, tres
-
-# Aunque no podemos selecionar un elemento por su índice.
-nuestro_iterable[1]  # Genera un TypeError
-
-# Un iterable es un objeto que sabe como crear un iterador.
-nuestro_iterator = iter(nuestro_iterable)
-
-# Nuestro iterador es un objeto que puede recordar el estado mientras lo recorremos.
-# Obtenemos el siguiente objeto llamando la función __next__.
-nuestro_iterator.__next__()  #=> "uno"
-
-# Mantiene el estado mientras llamamos __next__.
-nuestro_iterator.__next__()  #=> "dos"
-nuestro_iterator.__next__()  #=> "tres"
-
-# Después que el iterador ha retornado todos sus datos, da una excepción StopIterator.
-nuestro_iterator.__next__() # Genera StopIteration
-
-# Puedes obtener todos los elementos de un iterador llamando a list() en el.
-list(dicc_lleno.keys())  #=> Retorna ["uno", "dos", "tres"]
-
-
 
 ####################################################
 ## 4. Funciones
@@ -360,7 +349,7 @@ list(dicc_lleno.keys())  #=> Retorna ["uno", "dos", "tres"]
 
 # Usa 'def' para crear nuevas funciones
 def add(x, y):
-    print("x es {} y y es {}".format(x, y))
+    print "x es %s y y es %s" % (x, y)
     return x + y    # Retorna valores con una la declaración return
 
 # Llamando funciones con parámetros
@@ -369,7 +358,6 @@ add(5, 6) #=> imprime "x es 5 y y es 6" y retorna 11
 # Otra forma de llamar funciones es con argumentos de palabras claves
 add(y=6, x=5)   # Argumentos de palabra clave pueden ir en cualquier orden.
 
-
 # Puedes definir funciones que tomen un número variable de argumentos
 def varargs(*args):
     return args
@@ -385,7 +373,6 @@ def keyword_args(**kwargs):
 # Llamémosla para ver que sucede
 keyword_args(pie="grande", lago="ness") #=> {"pie": "grande", "lago": "ness"}
 
-
 # Puedes hacer ambas a la vez si quieres
 def todos_los_argumentos(*args, **kwargs):
     print args
@@ -423,28 +410,23 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
 # Podemos usar listas por comprensión para mapeos y filtros agradables
 [add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
 [x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
-# también hay diccionarios
-{k:k**2 for k in range(3)} #=> {0: 0, 1: 1, 2: 4}
-# y conjuntos por comprensión
-{c for c in "la cadena"} #=> {'d', 'l', 'a', 'n', ' ', 'c', 'e'}
 
 ####################################################
-## 5. Classes
+## 5. Clases
 ####################################################
 
-
 # Heredamos de object para obtener una clase.
 class Humano(object):
 
     # Un atributo de clase es compartido por todas las instancias de esta clase
     especie = "H. sapiens"
 
-    # Constructor basico
+    # Constructor básico, se llama al instanciar la clase.
     def __init__(self, nombre):
         # Asigna el argumento al atributo nombre de la instancia
         self.nombre = nombre
 
-    # Un metodo de instancia. Todos los metodos toman self como primer argumento
+    # Un método de instancia. Todos los metodos toman self como primer argumento
     def decir(self, msg):
        return "%s: %s" % (self.nombre, msg)
 
@@ -454,7 +436,7 @@ class Humano(object):
     def get_especie(cls):
         return cls.especie
 
-    # Un metodo estatico es llamado sin la clase o instancia como referencia
+    # Un metodo estático es llamado sin la clase o instancia como referencia
     @staticmethod
     def roncar():
         return "*roncar*"
@@ -485,12 +467,12 @@ Humano.roncar() #=> "*roncar*"
 
 # Puedes importar módulos
 import math
-print(math.sqrt(16)) #=> 4.0
+print math.sqrt(16) #=> 4.0
 
 # Puedes obtener funciones específicas desde un módulo
 from math import ceil, floor
-print(ceil(3.7)) #=> 4.0
-print(floor(3.7))#=> 3.0
+print ceil(3.7)  #=> 4.0
+print floor(3.7) #=> 3.0
 
 # Puedes importar todas las funciones de un módulo
 # Precaución: Esto no es recomendable
@@ -513,48 +495,52 @@ dir(math)
 ## 7. Avanzado
 ####################################################
 
-# Los generadores te ayudan a hacer un código perezoso (lazy)
+# Los generadores permiten evaluación perezosa
 def duplicar_numeros(iterable):
     for i in iterable:
         yield i + i
 
-# Un generador crea valores sobre la marcha.
-# En vez de generar y retornar todos los valores de una vez, crea uno en cada iteración.
-# Esto significa que valores más grandes que 15 no serán procesados en 'duplicar_numeros'.
-# Fíjate que 'range' es un generador. Crear una lista 1-900000000 tomaría mucho tiempo en crearse.
-_rango = range(1, 900000000)
-# Duplicará todos los números hasta que un resultado >= se encuentre.
-for i in duplicar_numeros(_rango):
-    print(i)
+# Un generador crea valores sobre la marcha
+# En vez de generar y devolver todos los valores de una vez, crea un valor
+# en cada iteración. En este ejemplo los valores mayores que 15 no serán 
+# procesados en duplicar_numeros.
+# Nota: xrange es un generador que hace lo mismo que range.
+# Crear una lista de 1 a 900000000 lleva mucho tiempo y ocupa mucho espacio.
+# xrange crea un generador, mientras que range crea toda la lista.
+# Añadimos un guión bajo a los nombres de variable que coinciden con palabras
+# reservadas de python.
+xrange_ = xrange(1, 900000000)
+
+# duplica todos los números hasta que encuentra un resultado >= 30
+for i in duplicar_numeros(xrange_):
+    print i
     if i >= 30:
         break
 
-
 # Decoradores
-# en este ejemplo 'pedir' envuelve a 'decir'
-# Pedir llamará a 'decir'. Si decir_por_favor es True entonces cambiará el mensaje a retornar
+# en este ejemplo pedir rodea a hablar
+# Si por_favor es True se cambiará el mensaje.
 from functools import wraps
 
 
-def pedir(_decir):
-    @wraps(_decir)
+def pedir(target_function):
+    @wraps(target_function)
     def wrapper(*args, **kwargs):
-        mensaje, decir_por_favor = _decir(*args, **kwargs)
-        if decir_por_favor:
-            return "{} {}".format(mensaje, "¡Por favor! Soy pobre :(")
-        return mensaje
+        msg, por_favor = target_function(*args, **kwargs)
+        if por_favor:
+            return "{} {}".format(msg, "¡Por favor! Soy pobre :(")
+        return msg
 
     return wrapper
 
 
 @pedir
-def say(decir_por_favor=False):
-    mensaje = "¿Puedes comprarme una cerveza?"
-    return mensaje, decir_por_favor
-
+def hablar(por_favor=False):
+    msg = "¿Me puedes comprar una cerveza?"
+    return msg, por_favor
 
-print(decir())  # ¿Puedes comprarme una cerveza?
-print(decir(decir_por_favor=True))  # ¿Puedes comprarme una cerveza? ¡Por favor! Soy pobre :()
+print hablar()  # ¿Me puedes comprar una cerveza?
+print hablar(por_favor=True)  # ¿Me puedes comprar una cerveza? ¡Por favor! Soy pobre :(
 ```
 
 ## ¿Listo para más?
@@ -563,10 +549,9 @@ print(decir(decir_por_favor=True))  # ¿Puedes comprarme una cerveza? ¡Por favo
 
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
 * [Dive Into Python](http://www.diveintopython.net/)
-* [Ideas for Python Projects](http://pythonpracticeprojects.com)
-* [The Official Docs](http://docs.python.org/3/)
+* [The Official Docs](http://docs.python.org/2.6/)
 * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [Python Module of the Week](http://pymotw.com/3/)
+* [Python Module of the Week](http://pymotw.com/2/)
 * [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
 
 ### Encuadernados