es: ресинхрон испанской локали с текущим ru (67 уроков)

modules/10-basics/10-hello-world/es/README.md

@@ -1,7 +1,58 @@
-Por lo general, el aprendizaje de un nuevo lenguaje de programación comienza con 'Hello, World!'. Este es un programa simple que muestra un saludo en la pantalla, y al mismo tiempo, familiariza al usuario con el nuevo lenguaje, así como con su sintaxis y la estructura del programa.
+El aprendizaje de un nuevo lenguaje de programación empieza tradicionalmente con el programa 'Hello, World!'. Es un programa simple que muestra un saludo en la pantalla y presenta la sintaxis y la estructura del nuevo lenguaje.
 
 ```text
 Hello, World!
 ```
 
-Esta tradición tiene más de cuarenta años, por lo cual no la romperemos. En la primera lección escribiremos el programa `Hello, World!`. Para hacerlo, debemos darle al ordenador un comando especial. En Python, este comando se llama `print()`.
+![Hello World](./assets/hello-world.png)
+
+Esta tradición tiene ya más de cuarenta años, y nosotros también empezaremos por ella. En la primera lección escribiremos el programa `Hello, World!`. En Python ese programa se ve así:
+
+```python
+print('Hello, World!')
+```
+
+El comando `print()` muestra en la pantalla el texto indicado entre paréntesis. En lugar del ejemplo se puede escribir cualquier otro texto.
+
+```python
+print('Hexlet - escuela de programación')
+```
+
+El comando sigue siendo el mismo, solo cambia el contenido de los paréntesis. Para que el programa entienda que se trata precisamente de texto, este se encierra entre comillas. Se pueden usar comillas simples `'...'` o dobles `"..."`, pero la comilla de apertura y la de cierre deben coincidir.
+
+```python
+print("Hexlet - escuela de programación")
+```
+
+Según el estándar de estilo de código aceptado en Python (PEP 8), se recomienda usar comillas simples para las cadenas. Si dentro de la cadena hay un apóstrofo, las comillas simples romperán la sintaxis, por lo que en esos casos se usan las dobles.
+
+```python
+print("it's a Python")  # apóstrofo dentro, por eso comillas dobles
+```
+
+## El significado de los símbolos
+
+El código está formado por comandos, y cada uno de ellos debe escribirse de una forma determinada. Además de las letras, en el código son importantes las comillas `'` y `"`, los paréntesis `()` y los signos de puntuación. Un signo omitido o confundido hará que el programa no se ejecute. ¿Puedes intentar determinar qué error se cometió en cada una de las líneas?
+
+```python
+print("it's a Python"
+print(it's a Python")
+prin("it's a Python")
+print('it's a Python")
+prInt("it's a Python")
+```
+
+Incluso una pequeña diferencia, por ejemplo una letra de más o un signo distinto, puede hacer que el programa no funcione. Esto también se aplica a las mayúsculas y minúsculas, es decir, a la diferencia entre letras grandes y pequeñas. Mientras que en el texto ordinario `Hola` y `hola` se ven iguales, para Python son palabras diferentes. Python considera `print`, `Print` y `PRINT` como comandos diferentes, y solo funcionará la primera variante.
+
+## Dónde practicar
+
+La teoría se asimila mejor cuando en paralelo ejecutas código y ves el resultado. Para eso sirve la consola interactiva de Python (REPL), donde los comandos se ejecutan línea por línea. Todo lo que aparece en la lección conviene probarlo [en la consola interactiva de Python](https://pyodide.org/en/stable/console.html).
+
+¿Cómo funciona esto técnicamente? Cualquier código escrito se pasa al intérprete de Python, que lo ejecuta y muestra en la pantalla el resultado de su trabajo.
+
+```text
+Código           Intérprete            Pantalla
+┌──────────┐     ┌─────────────┐     ┌──────────────┐
+│ print(…) │ ──→ │   Python    │ ──→ │ Hello, World!│
+└──────────┘     └─────────────┘     └──────────────┘
+```

modules/10-basics/20-comments/es/README.md

@@ -1,22 +1,57 @@
-
-Casi todos los lenguajes de programación permiten dejar comentarios en el código. Estos comentarios no son utilizados por el sistema intérprete. Son útiles únicamente para las personas que usan estas herramientas; para que los programadores puedan dejar notas para ellos mismos y también para otros programadores.
-
-A través de estos comentarios, se agregan explicaciones sobre cómo funciona el código, qué errores corregir o qué agregar más adelante.
+Además del propio código, en los archivos fuente se encuentran a menudo comentarios. Son líneas que el intérprete no procesa. Los programadores las escriben para explicar cómo funciona el código, señalar errores o recordar qué queda por terminar.
 
 ```python
 # Eliminar la línea de abajo después de implementar la tarea de registro
 print(10)
 ```
 
-Los comentarios en Python comienzan con el signo `#` y pueden aparecer en cualquier lugar del programa. Pueden ocupar toda una línea. Si una línea no es suficiente, se pueden crear varios comentarios:
+En Python todos los comentarios son de una sola línea. Empiezan con el símbolo especial #, tras el cual puede ir cualquier texto. Todo lo escrito después de # lo ignora el intérprete.
+
+```text
+# comentario     ──→  [ omitido por el intérprete ]
+print('hello')  ──→  [ ejecutado → hello ]
+# otro más       ──→  [ omitido por el intérprete ]
+```
+
+Un comentario puede ocupar toda la línea:
 
 ```python
-# ¡For Winterfell!
-# ¡For Lannisters!
+# For Winterfell!
+# For Lanisters!
 ```
 
-Un comentario puede estar en la línea después del código:
+O estar al final de una línea con código:
 
 ```python
-print('I am the King') # ¡For Lannisters!
+print('I am the King') # For Lannisters!
 ```
+
+Si hace falta dejar una explicación larga, se usan varias líneas con #:
+
+```python
+# The night is dark and
+# full of terrors.
+print('I am the King')
+```
+
+El intérprete ignora los comentarios. Los desarrolladores, gracias a ellos, entienden más rápido el código ajeno y no olvidan detalles importantes en el propio.
+
+## Comentarios de servicio
+
+Durante el trabajo te encontrarás con este código en nuestro editor:
+
+```python
+# BEGIN
+
+# END
+```
+
+*BEGIN* y *END* aquí son comentarios normales que no influyen de ninguna manera en el funcionamiento del programa. Muestran dónde escribir el código de la tarea.
+
+```python
+# BEGIN
+<aquí tu solución>
+# END
+```
+
+Cuando veas *BEGIN* y *END*, escribe tu código entre ellos y deja el resto sin cambios.

modules/10-basics/30-instructions/es/README.md

@@ -1,26 +1,69 @@
-Cuando preparamos una comida, seguimos la receta al pie de la letra. De lo contrario, la comida no saldrá como esperábamos. Esta regla también se aplica a la programación.
+Al comando `print('Hexlet')` podemos llamarlo instrucción: le dice al intérprete de Python qué hay que hacer. Esas instrucciones pueden ser tantas como se quiera. Cada una se ejecuta después de que ha terminado la anterior, y así, a partir de elementos simples, obtenemos un programa tan grande y complejo como queramos.
 
-Para ver el resultado esperado en la pantalla, es necesario darle al ordenador instrucciones claras, paso a paso. Una instrucción es un comando para el ordenador; una unidad de ejecución. En este caso, el código en Python es un conjunto de instrucciones. Se puede representar como una receta de cocina paso a paso.
+```text
+Instrucción 1: print('Hello')   →  ejecutada
+        ↓
+Instrucción 2: print('World')   →  ejecutada
+        ↓
+Instrucción 3: print('!')       →  ejecutada
+```
+
+Aquí tienes un ejemplo de código con dos instrucciones. Estas líneas le dicen al ordenador que muestre las frases en la pantalla.
+
+```python
+print('Mother of Dragons.') # Primera instrucción
+print('Dracarys!') # Segunda instrucción
+```
 
-El código en Python es ejecutado por un **intérprete** - es decir, un programa que ejecuta las instrucciones recibidas en orden. Al igual que los pasos en una receta, el conjunto de instrucciones para el intérprete se escriben en orden y se separan por saltos de línea.
+El resultado de la ejecución:
 
-Los desarrolladores deben entender el orden de las acciones en el código y ser capaces de dividir mentalmente el programa en partes independientes, fáciles de analizar.
+```text
+Mother of Dragons.
+Dracarys!
+```
 
-Veamos un ejemplo de código con dos instrucciones. Al ejecutarlo, se mostrarán en la pantalla dos frases en secuencia:
+## El orden importa
+
+El intérprete de Python ejecuta el código estrictamente en el orden en que lo escribiste. Si se intercambian las líneas:
 
 ```python
-print('Mother of Dragons.')
 print('Dracarys!')
-# => Mother of Dragons.
-# => Dracarys!
+print('Mother of Dragons.')
 ```
 
-Anteriormente hemos señalado que las instrucciones se separan por saltos de línea. Pero también hay otra forma: se pueden separar por punto y coma (`;`):
+en la pantalla también se intercambiarán:
+
+```text
+Dracarys!
+Mother of Dragons.
+```
+
+## Forma alternativa de escritura
+
+Normalmente las instrucciones se escriben en líneas separadas, pero Python permite unir varias instrucciones en una línea mediante `;`:
 
 ```python
-print('Mother of Dragons.'); print('Drakarys!')
+print('Mother of Dragons.'); print('Dracarys!');
 ```
 
-No hay diferencia técnica alguna entre la primera y la segunda opción: el intérprete entenderá las instrucciones de la misma manera. La única diferencia es que la segunda opción puede ser incómoda de leer para los humanos.
+Las dos versiones funcionan igual, pero la segunda variante es más difícil de leer. Por eso las instrucciones casi siempre se escriben una por línea.
+
+## Para qué hace falta esto
+
+Ahora escribimos programas muy simples, pero con el tiempo empezarán a complicarse, y una de las habilidades más importantes que ayudará a entenderlos es la capacidad de dividir (mentalmente) el programa en instrucciones independientes. Solo así se puede entender qué ocurre en el código. Abajo hay un ejemplo para llamar la atención; entenderlo por ahora no hace falta:
+
+```python
+def is_prime(number: int) -> bool:
+    if number < 2:
+        return False
+
+    divider = 2
+
+    while divider <= number / 2:
+        if number % divider == 0:
+            return False
 
-Es mejor colocar las instrucciones una debajo de la otra. De esta manera, será más fácil para tus colegas leer tu código, mantenerlo y realizar cambios en él.
+        divider += 1
+
+    return True
+```

modules/10-basics/40-testing/es/README.md

@@ -1,28 +1,36 @@
+Nuestro sitio comprueba automáticamente tus soluciones. ¿Cómo funciona?
 
-Nuestro sitio web verifica automáticamente tus soluciones (uso específico del término en programación). ¿Cómo funciona?
+En el caso más simple, la comprobación ejecuta tu código y compara la salida en pantalla con el resultado esperado. Por ejemplo, si la tarea dice: «Muestra el número 10 en la pantalla», tu código en Python puede verse así:
 
-En los casos más simples, el sistema simplemente ejecuta tu código y verifica lo que se muestra en la pantalla. Luego lo compara con lo que "esperábamos" según la tarea.
+```python
+print(10)
+```
+
+La comprobación ejecutará ese código y verificará que en la pantalla apareció realmente `10`. Si la salida coincide con la esperada, la solución se acepta. Si no, verás un error:
 
-En las lecciones más avanzadas, escribirás funciones, que son pequeños programas que toman información del mundo exterior y realizan operaciones con base en esta información. La verificación de tus soluciones en estos casos es un poco más complicada: el sistema ejecuta tu solución y le pasa cierta información. El sistema también sabe qué respuesta debería dar la función correcta con esos datos de entrada.
+```bash
+E   AssertionError: assert '9' == '10'
+E
+E     - 10
+E     + 9
+```
 
-Por ejemplo, si tu tarea es escribir una función que sume dos números, el sistema de verificación le pasará diferentes combinaciones de números y comparará la respuesta de tu función con las sumas reales. Si las respuestas coinciden en todos los casos, se considera que la solución es correcta.
+La línea con `+` muestra el resultado real que devolvió tu código, y la línea con `-` el valor esperado.
 
-Este enfoque se llama pruebas y se utiliza en el desarrollo diario real. Por lo general, el programador primero escribe una prueba, que es un programa de verificación, y luego escribe el programa que quería escribir. Durante el proceso, ejecuta las pruebas constantemente y verifica si se acerca a la solución.
+En las lecciones siguientes, más complejas, escribirás funciones. Reciben datos y devuelven un resultado. En esas tareas la comprobación funciona un poco de otra manera: llama a tu función con distintos argumentos y sabe de antemano qué respuesta debe salir en cada caso.
 
-Es por eso que nuestro sitio web indica "Pruebas aprobadas" cuando resuelves correctamente un problema.
+Por ejemplo, si hay que escribir una función que sume dos números, la comprobación le pasará distintos pares de números y comparará el resultado con la suma correcta. Si en todos los casos las respuestas coinciden, la solución se considera correcta.
 
-Aquí tienes un ejemplo sencillo: en una de las futuras lecciones, tendrás que escribir una función que realice cálculos y devuelva una respuesta. Supongamos que cometiste un pequeño error y la función devolvió un número incorrecto. El sistema responderá algo así:
+Ese enfoque se llama pruebas, y se usa en el desarrollo real. Las pruebas ayudan a comprobar si el programa funciona correctamente y a detectar rápido un error después de los cambios.
 
-```text
-AssertionError: '10' != '35'
-```
+Precisamente por eso nuestro sitio dice «Pruebas aprobadas» cuando has resuelto bien la tarea.
 
-Lo más importante sigue después de los dos puntos: "el valor '10' no es igual al valor esperado '35'". Es decir, la función correcta debería haber devuelto 35, pero la solución actual no funciona correctamente y devuelve 10.
+## ¿Es mi error o no?
 
-También vale la pena mencionar que si ves que en el editor ya hay algún código junto con los comentarios `BEGIN` y `END`, generalmente significa que debes escribir tu código entre estos comentarios. No debes modificar de antemano el código que se te proporciona, ya que esto puede afectar la verificación de la solución. En resumen, si ves líneas con los comentarios `BEGIN` y `END`, ¡escribe tu código en el espacio que se encuentra entre estos!
+A veces, durante la resolución, parecerá que hiciste todo correctamente pero la comprobación no acepta la solución. Eso ocurre en muy raras ocasiones. Las pruebas se ejecutan automáticamente después de cada cambio, así que una comprobación rota normalmente no llega al sitio.
 
----
+En la inmensa mayoría de esos casos el error está en el código de la solución. Puede ser muy poco visible: en lugar de una letra inglesa se escribió por accidente una rusa, en lugar de mayúscula se usó minúscula, o se olvidó mostrar una coma. También hay situaciones más complicadas. Por ejemplo, la solución funciona para un conjunto de datos de entrada, pero no para otro.
 
-A veces, durante el proceso de resolución, puede parecer que has hecho todo correctamente, pero el sistema se comporta de manera "caprichosa" y no acepta la solución. Este comportamiento es prácticamente imposible. Las pruebas no funcionales simplemente no pueden llegar al sitio web; se ejecutan automáticamente después de cada cambio. En la gran mayoría de estos casos (y todos nuestros proyectos en conjunto han realizado millones de verificaciones a lo largo de los años), el error se encuentra en el código de la solución. Puede ser muy sutil, como haber ingresado accidentalmente una letra rusa en lugar de una letra en inglés; usar minúsculas en lugar de mayúsculas; o olvidar poner una coma, por ejemplo. Otros casos son más complicados. Es posible que tu solución funcione para un conjunto de datos de entrada, pero no funcione para otro. Por lo tanto, siempre lee atentamente la descripción del problema y los resultados de las pruebas. Casi seguro que habrá alguna indicación sobre el error.
+Por eso lee siempre con atención el enunciado de la tarea y la salida de las pruebas. Ahí casi con seguridad hay una indicación del error.
 
-Sin embargo, si estás seguro de que hay un error o has encontrado alguna imprecisión, siempre puedes señalarlo. Al final de cada teoría hay un enlace al contenido de la lección en GitHub (¡este proyecto es completamente abierto!). Al ir allí, puedes escribir un issue, ver el contenido de las pruebas (donde se muestra cómo se llama tu código) e incluso enviar un pull request. Si esto aún te resulta confuso, únete a nuestra [comunidad en Telegram](https://t.me/hexletcommunity/3), allí en el canal *'Feedback'* siempre estaremos dispuestos a ayudar.
+Y si estás seguro de que el problema está en la tarea o encontraste una imprecisión, escribe a nuestra [comunidad](https://t.me/hexletcommunity), al canal _'Feedback'_.