fetched upstream and made some translations to Python

6 files changed, 583 insertions, 424 deletions

diff --git a/es-es/clojure-es.html.markdown b/es-es/clojure-es.html.markdown
index 150d0bb2..62935ebe 100644
--- a/es-es/clojure-es.html.markdown
+++ b/es-es/clojure-es.html.markdown
@@ -9,28 +9,30 @@ translators:
 lang: es-es
 ---
 
-Clojure es un lenguaje de la familia Lisp desarrollado sobre la Máquina Virtual
-de Java. Tiene un énfasis mayor en la [programación funcional](https://es.wikipedia.org/wiki/Programación_funcional) pura
-que Common Lisp, pero incluyendo la posibilidad de usar [SMT](https://es.wikipedia.org/wiki/Memoria_transacional) para manipular
+Clojure es un lenguaje de la familia Lisp desarrollado para la Máquina Virtual
+de Java. Tiene un énfasis mayor en la
+[programación funcional](https://es.wikipedia.org/wiki/Programación_funcional)
+pura que Common Lisp, pero incluye varias utilidades de
+[SMT](https://es.wikipedia.org/wiki/Memoria_transacional) para manipular
 el estado según se presente.
 
-Esta combinación le permite gestionar la concurrencia de manera muy sencilla
-y a menudo automáticamente.
+Esta combinación le permite gestionar el procesamiento concurrente de manera
+muy sencilla, y a menudo automáticamente.
 
-(Necesitas la versión de Clojure 1.2 o posterior)
+(Necesitas la versión de Clojure 1.2 o reciente)
 
 
 ```clojure
-; Los comentatios comienzan con punto y coma.
+; Los comentarios comienzan con punto y coma.
 
-; Clojure se escribe mediante "forms" (patrones), los cuales son
-; listas de objectos entre paréntesis, separados por espacios en blanco.
+; Clojure se escribe mediante patrones ("forms"), los cuales son
+; listas de cosas entre paréntesis, separados por espacios en blanco.
 
-; El "reader" (lector) de Clojure asume que el primer objeto es una
-; función o una macro que se va a llamar, y que el resto son argumentos.
+; El lector ("reader") de Clojure asume que la primera cosa es una
+; función o una macro a llamar, y el resto son argumentos.
 
-; El primer form en un archivo debe ser ns, para establecer el namespace (espacio de
-; nombres)
+; La primera llamada en un archivo debe ser ns, para establecer el espacio de
+; nombres ("namespace")
 (ns learnclojure)
 
 ; Algunos ejemplos básicos:
@@ -51,69 +53,70 @@ y a menudo automáticamente.
 ; También es necesaria la negación para las operaciones lógicas
 (not true) ; => false
 
-; Cuando se anidan Los patrones, estos funcionan de la manera esperada
+; Los patrones anidados funcionan como esperas
 (+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
 
 ; Tipos
 ;;;;;;;;;;;;;
 
-; Clojure usa los tipos de objetos de Java para booleanos, strings (cadenas de
-; caracteres) y números.
-; Usa class para saber de qué tipo es.
-(class 1); Los enteros son java.lang.Long por defecto
-(class 1.); Los numeros en coma flotante son java.lang.Double
-(class ""); Los strings van entre comillas dobles, y son
-; son java.lang.String
-(class false); Los Booleanos son java.lang.Boolean
+; Clojure usa los tipos de objetos de Java para booleanos, cadenas de
+; caracteres ("strings") y números.
+; Usa class para inspeccionarlos.
+(class 1); Los números enteros literales son java.lang.Long por defecto
+(class 1.); Los números en coma flotante literales son java.lang.Double
+(class ""); Los strings siempre van entre comillas dobles, y son
+          ; java.lang.String
+(class false); Los booleanos son java.lang.Boolean
 (class nil); El valor "null" se escribe nil
 
-; Si quieres crear una lista de datos, precedela con una comilla
-; simple para evitar su evaluación
+; Si quieres crear una lista literal de datos, usa ' para evitar su evaluación
 '(+ 1 2) ; => (+ 1 2)
-; (que es una abreviatura de (quote (+ 1 2)) )
+; (que es una abreviatura de (quote (+ 1 2)))
 
-; Puedes evaluar una lista precedida por comilla  con eval
+; Puedes evaluar una lista precedida por una comilla con eval
 (eval '(+ 1 2)) ; => 3
 
 ; Colecciones & Secuencias
 ;;;;;;;;;;;;;;;;;;;
 
-; Las Listas están basadas en las listas enlazadas, mientras que los Vectores en
-; arrays.
+; Las Listas están basadas en listas enlazadas, mientras que los Vectores en
+; arreglos.
 ; ¡Los Vectores y las Listas también son clases de Java!
 (class [1 2 3]); => clojure.lang.PersistentVector
 (class '(1 2 3)); => clojure.lang.PersistentList
 
-; Una lista podría ser escrita como (1 2 3), pero debemos ponerle una
-; comilla simple delante para evitar que el reader piense que es una función.
+; Una lista podría ser escrita como (1 2 3), pero debemos precederle una
+; comilla para evitar que el lector ("reader") piense que es una función.
 ; Además, (list 1 2 3) es lo mismo que '(1 2 3)
 
-; Las "Colecciones" son solo grupos de datos
-; Tanto las listas como los vectores son colecciones:
+; Las Colecciones ("collections") son solo grupos de datos
+; Tanto las Listas como los Vectores son colecciones:
 (coll? '(1 2 3)) ; => true
 (coll? [1 2 3]) ; => true
 
-; Las "Secuencias" (seqs) son descripciones abstractas de listas de datos.
-; Solo las listas son seqs.
+; Las Secuencias ("seqs") son descripciones abstractas de listas de datos.
+; Solo las listas son secuencias ("seqs").
 (seq? '(1 2 3)) ; => true
 (seq? [1 2 3]) ; => false
 
-; Una seq solo necesita proporcionar una entrada cuando es accedida.
-; Así que, las seqs pueden ser perezosas -- pueden establecer series infinitas:
+; Una secuencia solo necesita proporcionar uno de sus elementos cuando es
+; accedido.
+; Así que, las secuencias pueden ser perezosas -- pueden definir series
+; infinitas:
 (range 4) ; => (0 1 2 3)
 (range) ; => (0 1 2 3 4 ...) (una serie infinita)
 (take 4 (range)) ;  (0 1 2 3)
 
-; Usa cons para agregar un elemento al inicio de una lista o vector
+; Usa cons para agregar un elemento al inicio de una Lista o Vector
 (cons 4 [1 2 3]) ; => (4 1 2 3)
 (cons 4 '(1 2 3)) ; => (4 1 2 3)
 
 ; conj agregará un elemento a una colección en la forma más eficiente.
-; Para listas, se añade al inicio. Para vectores, al final.
+; Para Listas, se añade al inicio. Para vectores, al final.
 (conj [1 2 3] 4) ; => [1 2 3 4]
 (conj '(1 2 3) 4) ; => (4 1 2 3)
 
-; Usa concat para concatenar listas o vectores
+; Usa concat para concatenar Listas o Vectores
 (concat [1 2] '(3 4)) ; => (1 2 3 4)
 
 ; Usa filter y map para actuar sobre colecciones
@@ -125,7 +128,7 @@ y a menudo automáticamente.
 ; = (+ (+ (+ 1 2) 3) 4)
 ; => 10
 
-; reduce puede tener un argumento indicando su valor inicial.
+; reduce puede tomar un argumento como su valor inicial también
 (reduce conj [] '(3 2 1))
 ; = (conj (conj (conj [] 3) 2) 1)
 ; => [3 2 1]
@@ -137,43 +140,42 @@ y a menudo automáticamente.
 ; su última expresión
 (fn [] "Hello World") ; => fn
 
-; (Necesitas rodearlo con paréntesis para invocarla)
+; (Necesitas rodearlo con paréntesis para llamarla)
 ((fn [] "Hello World")) ; => "Hello World"
 
-; Puedes crear una var (variable) mediante def
+; Puedes definir una variable ("var") mediante def
 (def x 1)
 x ; => 1
 
-; Asigna una función a una var
+; Asignar una función a una variable ("var")
 (def hello-world (fn [] "Hello World"))
 (hello-world) ; => "Hello World"
 
-; Puedes defn como atajo para lo anterior
+; Puedes usar defn como atajo para lo anterior
 (defn hello-world [] "Hello World")
 
-; El [] es el vector de argumentos de la función.
+; El [] es el Vector de argumentos de la función.
 (defn hello [name]
   (str "Hello " name))
 (hello "Steve") ; => "Hello Steve"
 
-; Otra abreviatura para crear funciones es:
+; Puedes usar esta abreviatura para definir funciones:
 (def hello2 #(str "Hello " %1))
 (hello2 "Fanny") ; => "Hello Fanny"
 
-; Puedes tener funciones multi-variadic: funciones con un numero variable de
-; argumentos
+; Puedes tener funciones multi-variables ("multi-variadic") también
 (defn hello3
   ([] "Hello World")
   ([name] (str "Hello " name)))
 (hello3 "Jake") ; => "Hello Jake"
 (hello3) ; => "Hello World"
 
-; Las funciones pueden usar argumentos extras dentro de un seq utilizable en la función
+; Las funciones pueden empaquetar argumentos extras en una secuencia para ti
 (defn count-args [& args]
   (str "You passed " (count args) " args: " args))
 (count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
 
-; Y puedes mezclarlos con el resto de argumentos declarados de la función.
+; Puedes combinar los argumentos regulares y los empaquetados
 (defn hello-count [name & args]
   (str "Hello " name ", you passed " (count args) " extra args"))
 (hello-count "Finn" 1 2 3)
@@ -183,17 +185,18 @@ x ; => 1
 ; Mapas
 ;;;;;;;;;;
 
-; Mapas de Hash y mapas de arrays comparten una misma interfaz. Los mapas de Hash
-; tienen búsquedas más rápidas pero no mantienen el orden de las claves.
+; Los Mapas de Hash ("HashMap") y Mapas de Arreglo ("ArrayMap") comparten una
+; interfaz. Los Mapas de Hash tienen búsquedas más rápidas pero no mantienen el
+; orden de las llaves.
 (class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap
 (class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
 
-; Los mapas de arrays se convertidos en mapas de Hash en la mayoría de
-; operaciones si crecen mucho, por lo que no debes preocuparte.
+; Los Mapas de Arreglo se convierten automáticamente en Mapas de Hash en la
+; mayoría de operaciones si crecen mucho, por lo que no debes preocuparte.
 
-; Los mapas pueden usar cualquier tipo para sus claves, pero generalmente las
-; keywords (palabras clave) son lo habitual.
-; Las keywords son parecidas a cadenas de caracteres con algunas ventajas de eficiencia
+; Los Mapas pueden usar cualquier tipo para sus llaves, pero generalmente las
+; Claves ("keywords") son lo habitual.
+; Las Claves son como strings con algunas ventajas de eficiencia
 (class :a) ; => clojure.lang.Keyword
 
 (def stringmap {"a" 1, "b" 2, "c" 3})
@@ -205,28 +208,28 @@ keymap ; => {:a 1, :c 3, :b 2}
 ; Por cierto, las comas son equivalentes a espacios en blanco y no hacen
 ; nada.
 
-; Recupera un valor de un mapa tratandolo como una función
+; Recupera un valor de un Mapa tratándola como una función
 (stringmap "a") ; => 1
 (keymap :a) ; => 1
 
-; ¡Las keywords pueden ser usadas para recuperar su valor del mapa, también!
+; ¡Las Claves pueden ser usadas para recuperar su valor del mapa, también!
 (:b keymap) ; => 2
 
 ; No lo intentes con strings.
 ;("a" stringmap)
 ; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
 
-; Si preguntamos por una clave que no existe nos devuelve nil
+; Recuperando una clave no existente nos devuelve nil
 (stringmap "d") ; => nil
 
-; Usa assoc para añadir nuevas claves a los mapas de Hash
+; Usa assoc para añadir nuevas claves a los Mapas de Hash
 (def newkeymap (assoc keymap :d 4))
 newkeymap ; => {:a 1, :b 2, :c 3, :d 4}
 
 ; Pero recuerda, ¡los tipos de Clojure son inmutables!
 keymap ; => {:a 1, :b 2, :c 3}
 
-; Usa dissoc para eliminar llaves
+; Usa dissoc para eliminar claves
 (dissoc keymap :a :b) ; => {:c 3}
 
 ; Conjuntos
@@ -238,50 +241,86 @@ keymap ; => {:a 1, :b 2, :c 3}
 ; Añade un elemento con conj
 (conj #{1 2 3} 4) ; => #{1 2 3 4}
 
-; Elimina elementos con disj
+; Elimina uno con disj
 (disj #{1 2 3} 1) ; => #{2 3}
 
-; Comprueba su existencia usando el conjunto como una función:
+; Comprueba su existencia usando al Conjunto como una función:
 (#{1 2 3} 1) ; => 1
 (#{1 2 3} 4) ; => nil
 
-; Hay más funciones en el namespace clojure.sets
+; Hay más funciones en el espacio de nombres clojure.sets
 
 ; Patrones útiles
 ;;;;;;;;;;;;;;;;;
 
-; Las construcciones lógicas en clojure son macros, y presentan el mismo aspecto
-; que el resto de forms.
+; Los operadores lógicos en clojure son solo macros, y presentan el mismo
+; aspecto que el resto de patrones.
 (if false "a" "b") ; => "b"
 (if false "a") ; => nil
 
-; Usa let para crear un binding (asociación) temporal
+; Usa let para definir ("binding") una variable temporal
 (let [a 1 b 2]
   (> a b)) ; => false
 
-; Agrupa expresiones mediante do
+; Agrupa sentencias mediante do
 (do
   (print "Hello")
   "World") ; => "World" (prints "Hello")
 
-; Las funciones tienen implicita la llamada a do
+; Las funciones tienen un do implícito
 (defn print-and-say-hello [name]
   (print "Saying hello to " name)
   (str "Hello " name))
 (print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff")
 
-; Y el let también
+; Y let también
 (let [name "Urkel"]
   (print "Saying hello to " name)
   (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
 
+; Usa las macros de tubería ("threading", "arrow", "pipeline" o "chain")
+; (-> y ->>) para expresar la transformación de datos de una manera más clara.
+
+; La macro Tubería-primero ("Thread-first") (->) inserta en cada patrón el
+; resultado de los previos, como el primer argumento (segundo elemento)
+(->
+   {:a 1 :b 2}
+   (assoc :c 3) ;=> (assoc {:a 1 :b 2} :c 3)
+   (dissoc :b)) ;=> (dissoc (assoc {:a 1 :b 2} :c 3) :b)
+
+; Esta expresión podría ser escrita como:
+; (dissoc (assoc {:a 1 :b 2} :c 3) :b)
+; y evalua a {:a 1 :c 3}
+
+; La macro Tubería-último ("Thread-last") hace lo mismo, pero inserta el
+; resultado de cada línea al *final* de cada patrón. Esto es útil para las
+; operaciones de colecciones en particular:
+(->>
+   (range 10)
+   (map inc)     ;=> (map inc (range 10)
+   (filter odd?) ;=> (filter odd? (map inc (range 10))
+   (into []))    ;=> (into [] (filter odd? (map inc (range 10)))
+                 ; Result: [1 3 5 7 9]
+
+; Cuando estés en una situación donde quieras tener más libertad en donde
+; poner el resultado de transformaciones previas de datos en una expresión,
+; puedes usar la macro as->. Con ella, puedes asignar un nombre especifico
+; a la salida de la transformaciones y usarlo como identificador en tus
+; expresiones encadenadas ("chain").
+
+(as-> [1 2 3] input
+  (map inc input);=> You can use last transform's output at the last position
+  (nth input 2) ;=>  and at the second position, in the same expression
+  (conj [4 5 6] input [8 9 10])) ;=> or in the middle !
+
+
 ; Módulos
 ;;;;;;;;;;;;;;;
 
 ; Usa use para obtener todas las funciones del módulo
 (use 'clojure.set)
 
-; Ahora podemos usar más operaciones de conjuntos
+; Ahora podemos usar más operaciones de Conjuntos
 (intersection #{1 2 3} #{2 3 4}) ; => #{2 3}
 (difference #{1 2 3} #{2 3 4}) ; => #{1}
 
@@ -291,19 +330,18 @@ keymap ; => {:a 1, :b 2, :c 3}
 ; Usa require para importar un módulo
 (require 'clojure.string)
 
-; Usa / para llamar a las funciones de un módulo
+; Usa / para llamar las funciones de un módulo
 ; Aquí, el módulo es clojure.string y la función es blank?
 (clojure.string/blank? "") ; => true
 
-; Puedes asignarle una abreviatura a un modulo al importarlo
+; Puedes asignarle una sobrenombre a un modulo al importarlo
 (require '[clojure.string :as str])
 (str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst."
-; (#"" es una expresión regular)
+; (#"" es una expresión regular literal)
 
-; Puedes usar require (y use, pero no lo hagas) desde un espacio de nombre
+; Puedes usar require (y use, pero no lo hagas) desde un espacio de nombres
 ; usando :require,
-; No necesitas preceder con comilla simple tus módulos si lo haces de esta
-; forma.
+; No necesitas preceder con comilla tus módulos si lo haces de esta manera.
 (ns test
   (:require
     [clojure.string :as str]
@@ -312,8 +350,8 @@ keymap ; => {:a 1, :b 2, :c 3}
 ; Java
 ;;;;;;;;;;;;;;;;;
 
-; Java tiene una enorme librería estándar, por lo que resulta util
-; aprender como interactuar con ella.
+; Java tiene una enorme y útil librería estándar, por lo que querrás
+; aprender como hacer uso de ella.
 
 ; Usa import para cargar un módulo de java
 (import java.util.Date)
@@ -326,14 +364,15 @@ keymap ; => {:a 1, :b 2, :c 3}
 ; Usa el nombre de la clase con un "." al final para crear una nueva instancia
 (Date.) ; <un objeto Date>
 
-; Usa "." para llamar a métodos o usa el atajo ".método"
+; Usa "." para llamar métodos. O, usa el atajo ".método"
 (. (Date.) getTime) ; <un timestamp>
-(.getTime (Date.)) ; exactamente la misma cosa
+(.getTime (Date.)) ; exactamente lo mismo.
 
 ; Usa / para llamar métodos estáticos.
 (System/currentTimeMillis) ; <un timestamp> (System siempre está presente)
 
-; Usa doto para hacer frente al uso de clases (mutables) más tolerable
+; Usa doto para lidiar con el uso de clases (mutables) de una manera más
+; tolerable
 (import java.util.Calendar)
 (doto (Calendar/getInstance)
   (.set 2000 1 1 0 0 0)
@@ -342,9 +381,9 @@ keymap ; => {:a 1, :b 2, :c 3}
 ; STM
 ;;;;;;;;;;;;;;;;;
 
-; Software Transactional Memory es un mecanismo que usa clojure para gestionar
-; el estado persistente. Hay unas cuantas construcciones en clojure que
-; hacen uso de este mecanismo.
+; La Memoria Transaccional ("Software Transactional Memory" / "STM") es un
+; mecanismo que usa clojure para gestionar la persistecia de estado. Hay unas
+; cuantas construcciones en clojure que hacen uso de él.
 
 ; Un atom es el más sencillo. Se le da un valor inicial
 (def my-atom (atom {}))
@@ -352,14 +391,16 @@ keymap ; => {:a 1, :b 2, :c 3}
 ; Actualiza un atom con swap!
 ; swap! toma una función y la llama con el valor actual del atom
 ; como su primer argumento, y cualquier argumento restante como el segundo
-(swap! my-atom assoc :a 1) ; Establece my-atom al resultado de (assoc {} :a 1)
-(swap! my-atom assoc :b 2) ; Establece my-atom al resultado de (assoc {:a 1} :b 2)
+(swap! my-atom assoc :a 1) ; Establece my-atom al resultado
+                           ; de (assoc {} :a 1)
+(swap! my-atom assoc :b 2) ; Establece my-atom al resultado
+                           ; de (assoc {:a 1} :b 2)
 
-; Usa '@' para no referenciar al atom sino para obtener su valor
+; Usa '@' para no referenciar al atom y obtener su valor
 my-atom  ;=> Atom<#...> (Regresa el objeto Atom)
 @my-atom ; => {:a 1 :b 2}
 
-; Un sencillo contador usando un atom sería
+; Aquí está un sencillo contador usando un atom
 (def counter (atom 0))
 (defn inc-counter []
   (swap! counter inc))
@@ -372,22 +413,25 @@ my-atom  ;=> Atom<#...> (Regresa el objeto Atom)
 
 @counter ; => 5
 
-; Otros forms que utilizan STM son refs y agents.
+; Otras construcciones de STM son refs y agents.
 ; Refs: http://clojure.org/refs
 ; Agents: http://clojure.org/agents
+```
+
 ### Lectura adicional
 
-Ésto queda lejos de ser exhaustivo, pero espero que sea suficiente para que puedas empezar tu camino.
+Ésto queda lejos de ser exhaustivo, pero ojalá que sea suficiente para que
+puedas empezar tu camino.
 
 Clojure.org tiene muchos artículos:
-[http://clojure.org/](http://clojure.org/)
+[http://clojure.org](http://clojure.org)
 
 Clojuredocs.org contiene documentación con ejemplos para la mayoría de
 funciones principales (pertenecientes al core):
-[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
+[http://clojuredocs.org/quickref](http://clojuredocs.org/quickref)
 
 4Clojure es una genial forma de mejorar tus habilidades con clojure/FP:
 [http://www.4clojure.com/](http://www.4clojure.com/)
 
-Clojure-doc.org (sí, de verdad) tiene un buen número de artículos con los que iniciarse en Clojure:
-[http://clojure-doc.org/](http://clojure-doc.org/)
+Clojure-doc.org (sí, de verdad) tiene un buen número de artículos con los que
+iniciarse en Clojure: [http://clojure-doc.org](http://clojure-doc.org)
diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
index 31512dc4..050154c7 100644
--- a/es-es/javascript-es.html.markdown
+++ b/es-es/javascript-es.html.markdown
@@ -1,7 +1,7 @@
 ---
 language: javascript
 contributors:
-    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Leigh Brenecki", "https://leigh.net.au"]
     - ["Ariel Krakowski", "http://www.learneroo.com"]
 translators:
     - ["Daniel Zendejas","https://github.com/DanielZendejas"]
@@ -19,8 +19,8 @@ para front-end que Java.
 Sin embargo, JavaScript no sólo se limita a los navegadores web: Node.js, un proyecto que proporciona un entorno de ejecución independiente para el motor V8 de Google Chrome, se está volviendo más y más popular.
 
 ¡La retroalimentación es bienvenida! Puedes encontrarme en: 
-[@adambrenecki](https://twitter.com/adambrenecki), o
-[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
+[@ExcitedLeigh](https://twitter.com/ExcitedLeigh), o
+[l@leigh.net.au](mailto:l@leigh.net.au).
 
 ```js
 // Los comentarios en JavaScript son los mismos como comentarios en C. 
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
diff --git a/es-es/sql-es.html.markdown b/es-es/sql-es.html.markdown
new file mode 100644
index 00000000..1ee0d454
--- /dev/null
+++ b/es-es/sql-es.html.markdown
@@ -0,0 +1,115 @@
+---
+language: SQL
+filename: learnsql-es.sql
+contributors:
+  - ["Bob DuCharme", "http://bobdc.com/"]
+translators:
+  - ["FedeHC", "https://github.com/FedeHC"]
+lang: es-es
+---
+
+El lenguaje de consulta estructurada (SQL en inglés) es un lenguaje estándar ISO para crear y trabajar con bases de datos almacenados en un conjunto de tablas. Las implementaciones generalmente añaden sus propias extensiones al lenguaje; [Comparación entre diferentes implementaciones de SQL](http://troels.arvin.dk/db/rdbms/) es una buena referencia sobre las diferencias entre distintos productos.
+
+Las implementaciones típicamente proveen de una línea de comandos donde uno puede introducir los comandos que se muestran aquí en forma interactiva, y también ofrecen una forma de ejecutar una serie de estos comandos almacenados en un archivo de script (mostrar que uno ha terminado con el prompt interactivo es un buen ejemplo de algo que no está estandarizado - la mayoría de las implementaciones de SQL soportan las palabras clave QUIT, EXIT, o ambas).
+
+Varios de estos comandos que sirven de ejemplo asumen que la [base de datos de empleados de muestra de MySQL](https://dev.mysql.com/doc/employee/en/) disponible en [github](https://github.com/datacharmer/test_db) ya ha sido cargada. Los archivos github son scripts de comandos, similares a los comandos que aparecen a continuación, que crean y cargan tablas de datos sobre los empleados de una empresa ficticia. La sintaxis para ejecutar estos scripts dependerá de la implementación de SQL que esté utilizando. Una aplicación que se ejecuta desde el prompt del sistema operativo suele ser lo habitual.
+
+
+```sql
+-- Los comentarios empiezan con dos guiones. Se termina cada comando con punto
+-- y coma.
+
+-- SQL no distingue entre mayúsculas y minúsculas en palabras clave. Los
+-- comandos de ejemplo que aquí se muestran siguen la convención de ser escritos
+-- en mayúsculas porque hace más fácil distinguirlos de los nombres de las bases
+-- de datos, de las tablas y de las columnas.
+
+-- A cont. se crea y se elimina una base de datos. Los nombres de la base de
+-- datos y de la tabla son sensibles a mayúsculas y minúsculas.
+CREATE DATABASE someDatabase;
+DROP DATABASE someDatabase;
+
+-- Lista todas las bases de datos disponibles.
+SHOW DATABASES;
+
+-- Usa una base de datos existente en particular.
+USE employees;
+
+-- Selecciona todas las filas y las columnas de la tabla departments en la base
+-- de datos actual. La actividad predeterminada es que el intérprete desplace
+-- los resultados por la pantalla.
+SELECT * FROM departments;
+
+-- Recupera todas las filas de la tabla departments, pero sólo las columnas
+-- dept_no y dept_name.
+-- Separar los comandos en varias líneas está permitido.
+SELECT dept_no,
+       dept_name FROM departments;
+
+-- Obtiene todas las columnas de departments, pero se limita a 5 filas.
+SELECT * FROM departments LIMIT 5;
+
+-- Obtiene los valores de la columna dept_name desde la tabla departments cuando
+-- dept_name tiene como valor la subcadena 'en'.
+SELECT dept_name FROM departments WHERE dept_name LIKE '%en%';
+
+-- Recuperar todas las columnas de la tabla departments donde la columna
+-- dept_name comienza con una 'S' y tiene exactamente 4 caracteres después
+-- de ella.
+SELECT * FROM departments WHERE dept_name LIKE 'S____';
+
+-- Selecciona los valores de los títulos de la tabla titles, pero no muestra
+-- duplicados.
+SELECT DISTINCT title FROM titles;
+
+-- Igual que el anterior, pero ordenado por los valores de title (se distingue
+-- entre mayúsculas y minúsculas).
+SELECT DISTINCT title FROM titles ORDER BY title;
+
+-- Muestra el número de filas de la tabla departments.
+SELECT COUNT(*) FROM departments;
+
+-- Muestra el número de filas en la tabla departments que contiene 'en' como
+-- subcadena en la columna dept_name.
+SELECT COUNT(*) FROM departments WHERE dept_name LIKE '%en%';
+
+-- Una unión (JOIN) de información desde varias tablas: la tabla titles muestra
+-- quién tiene qué títulos de trabajo, según sus números de empleados, y desde
+-- qué fecha hasta qué fecha. Se obtiene esta información, pero en lugar del
+-- número de empleado se utiliza el mismo como una referencia cruzada a la
+-- tabla employee para obtener el nombre y apellido de cada empleado (y se
+-- limita los resultados a 10 filas).
+SELECT employees.first_name, employees.last_name,
+       titles.title, titles.from_date, titles.to_date
+FROM titles INNER JOIN employees ON
+       employees.emp_no = titles.emp_no LIMIT 10;
+
+-- Se enumera todas las tablas de todas las bases de datos. Las implementaciones
+-- típicamente proveen sus propios comandos para hacer esto con la base de datos
+-- actualmente en uso.
+SELECT * FROM INFORMATION_SCHEMA.TABLES
+WHERE TABLE_TYPE='BASE TABLE';
+
+-- Crear una tabla llamada tablename1, con las dos columnas mostradas, a partir
+-- de la base de datos en uso. Hay muchas otras opciones disponibles para la
+-- forma en que se especifican las columnas, como por ej. sus tipos de datos.
+CREATE TABLE tablename1 (fname VARCHAR(20), lname VARCHAR(20));
+
+-- Insertar una fila de datos en la tabla tablename1. Se asume que la tabla ha
+-- sido definida para aceptar estos valores como aptos.
+INSERT INTO tablename1 VALUES('Richard','Mutt');
+
+-- En tablename1, se cambia el valor de fname a 'John' para todas las filas que
+-- tengan un valor en lname igual a 'Mutt'.
+UPDATE tablename1 SET fname='John' WHERE lname='Mutt';
+
+-- Se borra las filas de la tabla tablename1 donde el valor de lname comience
+-- con 'M'.
+DELETE FROM tablename1 WHERE lname like 'M%';
+
+-- Se borra todas las filas de la tabla tablename1, dejando la tabla vacía.
+DELETE FROM tablename1;
+
+-- Se elimina toda la tabla tablename1 por completo.
+DROP TABLE tablename1;
+```
diff --git a/es-es/yaml-es.html.markdown b/es-es/yaml-es.html.markdown
index cd3143fb..582fa60e 100644
--- a/es-es/yaml-es.html.markdown
+++ b/es-es/yaml-es.html.markdown
@@ -3,7 +3,7 @@ language: yaml
 lang: es-es
 filename: learnyaml-es.yaml
 contributors:
-  - ["Adam Brenecki", "https://github.com/adambrenecki"]
+  - ["Leigh Brenecki", "https://github.com/adambrenecki"]
   - ["Everardo Medina","https://github.com/everblut"]
 translators:
   - ["Daniel Zendejas","https://github.com/DanielZendejas"]