Y ahora dale, sin miedo.
Tags: beginners
Published: 2020-05-12 19:43:02

#### A lo largo de este texto voy a intentar borrar al menos algunos preconceptos sobre la programación, como que es complicadísimo o que hay que ser muy inteligente.
---
 **Para comenzar, ¿qué es un lenguaje de programación?**

Así como las personas nos entendemos mediante un idioma, las computadoras entienden un único lenguaje: el de máquinas. Un lenguaje de programación es una manera de interactuar con un procesador (también conocido como microprocesador, es el corazón y cerebro de una computadora), de manera tal de poder proporcionarle una serie de instrucciones que debe llevar a cabo. La computadora (es decir, el procesador) **SIEMPRE** va a hacer lo que le indiquemos que haga, ni más, ni menos.

Está bien, todo muy lindo, pero ¿de qué me sirve esto? Bueno, la realidad es que hay mucho misterio e ideas generalizadas sobre la programación (si bien es cierto que se está dando un progresivo proceso de desmitificación). En sus orígenes, comunicarse con una computadora realmente era algo muy complicado y que por su naturaleza hubiera producido rechazo en muchas personas. Lo primero primero, era esto: 
![alt text](https://http2.mlstatic.com/tarjeta-perforada-ibm-D_NQ_NP_482225-MLV25394795285_022017-F.jpg)

Así como lo ven, esto era una _"cartulina"_ a la que una persona, con una maquinita, iba haciéndole las perforaciones que vemos en la imagen. Que hubiera agujeritos, implicaba que había zonas, donde **no** había agujeritos. Entonces, _agujereado_ y _no agujereado_  eran las únicas opciones y significaban dos cosas literalmente opuestas. Si bien en nuestros días las computadoras disminuyeron muchísimo de tamaño y tuvieron un aumento fenomenal en su capacidad de procesamiento, mantienen la misma idea, lo que seguramente alguna vez escucharon nombrar como "_unos y ceros_".

Dicho esto, desde que se crearon las primeras computadoras hasta hoy, hubo un montón de personas, muy capaces (y con mucho amor por la materia), que le dedicaron un montón de tiempo para que la programación sea cada vez más accesible para todo el mundo. Ella es **Margaret Hamilton**, directora del equipo de programadores de la misión Apolo XI, la primera expedición espacial que logró alunizar (el 20 de Julio de 1969). Aquí la podemos ver junto al código que este grupo escribió para semejante proeza. ![alt text](https://elpais.com/tecnologia/imagenes/2017/01/09/actualidad/1483980291_213857_1483980952_noticia_grande.jpg)

Estas personas se fueron encargando de armar "traductores" para que pudiéramos interactuar con las máquinas usando un lenguaje cada vez más parecido al __natural__ (el que hablamos a diario, o por lo menos, el que hablan en Estados Unidos). El código de la misión Apollo XI estaba escrito en un lenguaje que ya se servía de un traductor a _unos y ceros_. Estos lenguajes no son todos iguales y tienen una escala para medir su "lejanía" con el lenguaje de máquinas (unos y ceros). Esta escala de los lenguajes va desde el **bajo nivel** (más cerca del lenguaje de máquinas) al **alto nivel** (más lejos, y por lo tanto, más parecido al lenguaje natural).

A medida que fue pasando el tiempo, fueron apareciendo formas de programar cada vez más amigables, hasta llegar a los tiempos que corren, en los que ya es posible programar utilizando únicamente el mouse, arrastrando algunos _bloques_ de código. En este post voy a ejemplificar lo _alto_ que han llegado algunos lenguajes con uno que se llama **Python**. Este fue el lenguaje con el que yo di mis primeros pasos en esto de la programación, y cada día que pasa, lo quiero un poco más.

**Python** es un lenguaje particularmente amigable para quienes quieren empezar, debido a la simpleza de su _sintaxis_ (cada lenguaje tiene la suya propia, como puede pasar con el español y el inglés). En todo lenguaje de programación, hay algunas palabras claves o reservadas, que nos permiten darle una instrucción al procesador. En cada lenguaje, estas palabras claves son diferentes. También hay elementos en común entre todos los lenguajes, como el concepto de los tipos (no, no me refiero a los varones). El _tipado_ le permite al lenguaje determinar de qué manera tratar un elemento. De igual manera, nos resultaría imposible realizar las mismas operaciones con una palabra que con un número. Los números los podemos sumar, en cambio, las palabras, no.

Bien. Pero de vuelta, ¿de qué me sirve esto? Bueno, después de esta larga introducción, vayamos al barro. Quiero mostrarles lo simple que puede ser realizar una tarea, si bien _sencilla_, larga y repetitiva. Hay una página, que me gusta **mucho**, que fue con la que comencé a programar. La misma se llama [Project Euler](https://projecteuler.net) y tiene muchos problemas matemáticos, que solo podrías resolver _programáticamente_ (o si tuvieras **muchísimos** años de vida por delante).

Bien, veamos el primer desafío que la página nos propone: 

> ```If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.```
> ```Find the sum of all the multiples of 3 or 5 below 1000.```

En español:

> ```Si listamos todos los números naturales menores a 10 que son múltiplos de 3 o de 5, obtenemos el 3, el 5, el 6 y el 9. La suma de estos múltiplos es 23.```
> ```Hallar la suma de todos los múltiplos de 3 o de 5 que sean menores que 1000.```

Quizás hay muchas palabras que no escuchan hace mucho tiempo, pero si lo leen sin _asquito_, no parece un pedido complejo, ¿verdad? Nos están pidiendo los números que podamos dividir o por 3 o por 5 y sumarlos todos.

Como vemos en la consigna, si nos pidieran los menores que 10, sería algo corto y lo podríamos resolver a mano o mentalmente. 3, 5, 6, 9 y listo. La cuestión se _complejiza_ cuando nos piden los menores a 1.000 (que también podrían ser los menores a 10.000 o a 100.000, y hacerlo a mano sería todavía más engorroso).

Retomando el concepto del _tipado_, en este caso la respuesta va a ser un número, ya que nos están pidiendo una suma.

Ya que las máquinas tienen un traductor a unos y ceros, vamos a igualar las condiciones teniendo un traductor a lenguaje humano, así que tranqui.

Hay distintos tipos, números, palabras, o una lista de los tipos que acabamos de ver, es decir una lista de números o una lista de palabras. Acá es donde empieza a tomar importancia nuestra imaginación. Los números menores que 1.000, podrían formar todos parte de una lista o **rango** de números, ¿no?

```python
numero = 1 # Cada vez que yo diga "numero" me voy a estar refiriendo a 1.
palabra = "palabra" # Cada vez que yo diga "palabra" me voy a estar refiriendo a palabra.
menores_de_mil = range(1, 1000) # Cada vez que yo diga menores_de_mil me voy a estar
#                                 refiriendo a la lista de números, que seria 
#                                 [1, 2, 3, 4, ……………, 998, 999].
#                                 Fíjense que el último número no se incluye.
```

Ya estamos muy cerca de obtener el resultado. Los procesadores hacen muy bien las operaciones matemáticas, así que no tenemos que preocuparnos por eso. Y de lo bien que las hacen, también podemos saber con una sola tecla, si una división entre dos números enteros, me dejaría un resto o no (si no me sobra nada, entonces ese número es divisor). Esta tecla es el `%`.

Otra cosa que hacen muy bien los procesadores, es comparar si dos cosas son iguales. Vamos a aprovecharnos de esto, con la clave `==` (Esto se hace con dos iguales, porque con un solo igual le estaríamos diciendo al procesador que se acuerde de un valor). Veámoslo con un ejemplo.

```python
print(4 % 2) # "Mostrame el resto de la división de 4 por 2". En este caso, yo puedo 
#              dividir 4 por 2 y no me sobra nada, entonces, el 2 es un divisor de 4.
print(5 % 3) # "Mostrame el resto de la división de 5 por 3". En este caso, al dividir 
#               5 por 3 me van a sobrar 2, entonces 3 no es un divisor de 5.
  
print(2 == 3) # Decime, Python, ¿2, es igual a 3?
print(2 == 2) # Macanudo, y otra cosa, ¿2 es igual a 2?
```

Bueno, todo muy lindo pero, ¿de qué me sirve esto?

¡Esta es la parte interesante! Podemos decirle a nuestro _programa_ que se comporte de diferentes maneras en caso de que algo sea cierto o no. Entonces, pensemos el proceso que deberíamos llevar a cabo para poder realizar el desafío a mano.

1.   Armar una lista con todos los números menores que 1.000.
2.   Decidir cuáles de esos números cumplen con la condición que nos plantearon, en este caso, que sean múltiplos de 3 o de 5.
3.   Solo vamos a querer sumar los números que cumplan nuestra condición.

Para indicarle al procesador que se comporte de una manera en caso de que el número cumpla con la condición y de otra manera si no la cumpliera, existen dos palabras reservadas, `if` y `else`. (En español, `si pasa esto…` y `caso contrario…`)

Nos puede resultar un poco _ajeno_, pero lo podemos simplificar como una canilla, que puede estar abierta o cerrada. Si abrimos el grifo, saldrá agua, si lo cerramos, no saldrá nada. Esto puede pensarse como un **comportamiento binario**. (Siempre volvemos a los ceros y unos). Mejor veámoslo con un ejemplo.

```python
if(2 == 2): # Si es cierto que 2 es igual a 2
  print("Esto es verdadero!") # Mostrame la frase "Esto es verdadero!"
else: # Si es mentira que 2 es igual a 2 
  print("Esto es falso!") # Mostrame la frase "Esto es falso!"
# >>> Esto es verdadero!
if(2 == 5): # Si es cierto que 2 es igual a 5
  print("Esto es verdadero!") # Mostrame la frase "Esto es verdadero!"
else: # Si es mentira que 2 es igual a 5
  print("Esto es falso!") # Mostrame la frase "Esto es falso!"
# >>> Esto es falso!
```

Con lo que vimos hasta ahora, podríamos decidir qué comportamiento queremos que realice el procesador si los números son múltiplos de 3 o de 5. Existe una tercera palabra reservada para definir este tipo de comportamientos, `elif`. Esta palabra no tiene un significado real en inglés, si no que es como una mezcla entre las otras dos. Sería como un `o si no, si es`. Es muy útil cuando queremos definir un comportamiento con más de una posibilidad (que sea múltiplo de 3 ó que sea múltiplo de 5).

```python
resto_de_la_division_por_cinco = 303 % 5 # Cada vez que diga 
#                                          resto_de_la_division_por_cinco me voy a 
#                                          estar refiriendo al resto de esta división.

print("El resto de la división por cinco es:") # Quiero ver en pantalla la frase 
#                                                "El resto de la división por cinco es:"

print(resto_de_la_division_por_cinco) # Mostrame a lo que me refiero cuando digo 
#                                       resto_de_la_division_por_cinco



resto_de_la_division_por_tres = 303 % 3 # Cada vez que diga 
#                                         resto_de_la_division_por_tres me voy a
#                                         estar refiriendo al resto de esta división.
    
print("El resto de la división por tres es:") # Quiero ver en pantalla la frase
#                                               "El resto de la división por tres es:"
  
print(resto_de_la_division_por_tres) # Mostrame a lo que me refiero cuando digo 
#                                      resto_de_la_division_por_tres


if(resto_de_la_division_por_cinco == 0): # Si es cierto que 
#                                          resto_de_la_division_por_cinco es 0 
#                                          (o sea, si el 5 es divisor)
  print("Es múltiplo de 5!") # Decime "Es múltiplo de 5!"

elif(resto_de_la_division_por_tres == 0): # En cambio, si es cierto que 
#                                           resto_de_la_division_por_tres es 0 
#                                           (o sea, si el 3 es divisor)
   print("Es múltiplo de 3!") # Decime "Es múltiplo de 3!"

else: # Si todo lo que me dijiste antes es mentira
  print("No es múltiplo ni de 3 ni de 5 :(") # Decime "No es múltiplo ni de 3 ni de 5 :(" 
```

¡Genial! Ahora solo nos faltaría poder mirar todos los números y decidir si son múltiplos o no. Si tan solo hubiera algo capaz de mirar una lista **muy** rápido…
![alt text](https://media.giphy.com/media/l0G18gptStsYQrcL6/giphy.gif)

Para poder mirar una lista contamos con otra palabra reservada (Sí, otra… Por lo menos tienen nombres fáciles 😜 ). Esta vez se llama `for`. Deriva de una frase en inglés, `for each`, en español esta frase significa `para cada`. Con esta palabrita vamos a poder realizarle las operaciones que querramos a cada número que haya en la lista. Por ejemplo:

```python
lista_de_prueba = range(1, 6) # Cuando diga lista_de_prueba me voy a referir a la 
#                                lista de números [1, 2, 3, 4, 5] 
#                                (el último número del rango no está incluido)

for numero in lista_de_prueba: # Para cada número en la lista_de_prueba
  print("El número es:") # Quiero que me digas "El número es:"
  print(numero) # Y me muestres el número

# >>> El número es:
# >>> 1
# >>> El número es:
# >>> 2
# >>> El número es:
# >>> 3
# >>> El número es:
# >>> 4
# >>> El número es:
# >>> 5
```

¡Wow! ¡Cuánta magia! Ahora ya solo nos queda mezclar todas estas palabras reservadas y obtener el resultado.

```python
menores_de_mil = range(1, 1000) # Cada vez que yo diga menores_de_mil me voy a estar
#                                 refiriendo a la lista de números que seria 
#                                 [1, 2, 3, 4, ……………, 998, 999]. No incluimos el último.

resultado = 0 # Cada vez que yo diga resultado voy a referirme a este 0

for numero in menores_de_mil: # Para cada numero en la lista menores_de_mil

  if( (numero % 3) == 0 ): # Si cuando al número lo divido por 3 no me deja resto 
#                              (o sea que es divisible por 3)

    resultado = resultado + numero # Agarrá mi resultado, que originalmente era 0 y 
#                                    sumale el número. Por ejemplo, en el caso del 9, 
#                                    se va a dar cuenta que es divisible por 3 
#                                    y lo va a agregar a la cuenta.

  elif( (numero % 5) == 0 ): # Si al dividirlo por 3 me dejó resto, entonces fijate 
#                              si cuando al número lo divido por 5 no me deja resto 
#                              (o sea que es divisible por 5).

    resultado = resultado + numero # Agarrá mi resultado, que originalmente era 0 y 
#                                    sumale el número. Por ejemplo, en el caso del 10, 
#                                    se va a dar cuenta que es divisible por 5 
#                                    y lo va a agregar a la cuenta.

print("El resultado es: ", resultado) # Cuando hayas terminado de fijarte todos 
#                                       los números, mostrame el resultado!

# >>> El resultado es:  233168

#=============== Una versión sin las traducciones, para verlo más claro ================#

menores_de_mil = range(1, 1000)
resultado = 0
for numero in menores_de_mil:
  if( (numero % 3) == 0 ):
      resultado = resultado + numero
  elif( (numero % 5) == 0 ):
      resultado = resultado + numero
print("El resultado es: ", resultado)
# >>> El resultado es:  233168
```

Sin las traducciones queda más corto ¿no?

#### Espero haber aclarado algunas de las ideas que tenían sobre la programación antes de haberse cruzado con este texto. Gracias por haber leído hasta acá. Si todo esto les dio curiosidad y quieren aprender más, internet está repleto de páginas para aprender de forma gratuita muchos lenguajes, incluido Python. ¡Están a un Google de distancia!