Semana 4

Tipos de datos

Muchos lenguajes utilizan lo que se denomina “tipado estático” (statically typed). Esto
significa que al momento de declarar variables y constantes, deberemos siempre indicar el
tipo de dato asociado, esencialmente para una mejor gestión de los recursos de memoria
disponibles. Por ejemplo en C/C++, si deseamos utilizar una variable para operar con un
número entero, la declaramos como:

int vr01 = 50;

Si en cambio fuese necesario manejar un número con decimales, la declaración sería:

float vr02 = 50.3;

Como cualquier variable, podremos modificar su valor en todo momento, pero si intentamos
asignar un valor que no se corresponde con el tipo de dato, como por ejemplo vr01 = 15.5, el
compilador no lo permitirá, arrojando un error de tipos.

Por supuesto existen otros tipos de datos, por ejemplo para manejar cadenas de texto o
diferentes tipos numéricos, pero en esencia el concepto a recordar es el mencionado en el
primer párrafo: en los lenguajes de tipado estático, siempre deberemos indicar el tipo de
dato al momento de declarar una variable.
Otros lenguajes de alto nivel, como el caso característico de Python, no tienen este
requerimiento, por ejemplo:

nroEnt = 5
print(nroEnt)
imprimirá el valor 5, y

nroDec = 5.1
print(nroDec)

imprimirá el valor 21.3 (21.29999999)

La idea base es simplificar la escritura de código, internamente el sistema inferirá el tipo de

dato correcto a utilizar según los valores manejados por cada variable.
Sumadores. Contadores. Acumuladores

Estas son 3 de las operaciones más básicas que podemos realizar sobre datos. Esto no
significa que no sean utilizadas, muy por el contrario, siempre encontraremos este tipo de
instrucciones en todos los códigos, por más sencillos o complejos que sean.

Sumador

Un sumador, por supuesto, suma valores en un total. Ejemplo:

v1 = 10
v2 = 20
v3 = v1 + v2

En este caso hemos declarado 3 variables: v1 y v2 tienen los valores 10 y 20, v3 no ha sido
declarada de forma fija, sino que depende de los valores de v1 y v2, por ende en este
ejemplo, v3 tiene el valor actual de 30.

Contador

Como bien lo anticipa su nombre, un contador tiene como objetivo básico contar, por lo cual
se suele utilizar dentro de algún tipo de ciclo, comenzando en 0 e incrementando su valor en
1 cada vez que se cumple un recorrido (o loop) del ciclo, aunque lógicamente podría iniciar
en otro valor que no fuese 0. En pseudocódigo, podemos tener un ejemplo como:

Inicio
Declarar contador = 0
Abrir ciclo indefinido
contador = contador + 1
Si contador = 10 entonces
salir del ciclo
Cierra Si
Cierra ciclo
Imprimir contador

En este caso declaramos una variable llamada contador, que comienza con el valor 0.
Un ciclo, como veremos más adelante, es esencialmente un bloque que repite las
instrucciones contenidas dentro, con contador = contador + 1, estamos incrementando el
valor de la variable contador en 1 cada vez que el ciclo pasa por allí.
Con la condición debajo, si observamos que contador llega al valor 10, simplemente salimos
del ciclo, con lo cual al imprimir debajo contador, imprimirá el valor 10.

Acumulador

Un acumulador se comporta de forma similar, pero no incrementando de a 1, sino

acumulando los valores. Ejemplo:

Inicio
Declarar acu1 = 0
Declarar nro = 0
Abrir ciclo de 1 a 5
Pedir nro al usuario
acu1 = acu1 + nro
Cierra ciclo

Aquí lo que hacemos es solicitar 5 números al usuario, por supuesto no podemos saber de
antemano cuáles serán los números ingresados, sí podríamos restringir las entradas (por
ejemplo no permitiendo números negativos, o con decimales).

acu1 inicia en 0, pero en cada ciclo se le suma el valor de nro, que es el número ingresado
por el usuario.

De esta forma, si el usuario ingresa por ejemplo los números 16 3 3 1 y 20, la progresión del
valor de la variable acu1 sería:
- antes del ciclo: 0
- 1er ciclo: 16
- 2do ciclo: 19
- 3er ciclo: 22
- 4to ciclo: 23
- 5to ciclo: 43

Finalizaría entonces con el valor 43, resultante de sumar 16 + 3 + 3 + 1 + 20.

Estructuras de Control. Ciclos.

Sin dudas se encuentran también entre los elementos esenciales en cualquier código. En la
gran mayoría de los proyectos, llegará el momento en el que necesitaremos repetir la
ejecución de un paquete de instrucciones constantemente, o una determinada cantidad de
veces, y allí requeriremos de algún tipo de ciclo para poder hacerlo. Básicamente un ciclo
contendrá una lista de instrucciones, las ejecutará en orden y al llegar a la última, retornará
a la primera para repetir.

Cuando hablamos de ciclos, podemos hacer una clasificación en 3 tipos básicos:

● Infinitos
● Indefinidos
● Finitos

Un ciclo infinito se repetirá de forma continua mientras el programa se mantenga en

ejecución, respetando siempre el orden de los comandos, llegará al último, al completarlo
retornará al primero, y así mientras se mantenga funcionando el código.

Un ciclo indefinido tiene una esencia similar, pero puede “cortarse” en cualquier momento si
se da una determinada situación contemplada dentro del paquete de instrucciones que
repite, por ejemplo el pulsado de un botón. En el primer caso (infinito), el paquete se repetirá
mientras el programa se mantenga en ejecución; en este caso también lo hará, pero tan
pronto como el botón sea presionado, se interrumpirá y saldrá del ciclo.

Por último, un ciclo finito es simplemente aquel que se repite una cantidad prefijada de
veces, por ejemplo si deseamos solicitar 10 números al usuario, realizaremos un ciclo que
se repetirá obviamente solo 10 veces, y contendrá internamente el paquete de instrucciones
que permita ingresar un número y procesarlo.
Los comandos más habituales para realizar ciclos en los diferentes lenguajes, son for(),
while(), loop(), do loop() o do while(). Veamos un ejemplo en Python:

for ciclo in range(10):

print(ciclo)

Esta es una forma tradicional de repetir comandos una determinada cantidad de veces, en
este caso se imprimirán los números 0, 1, 2, 3, 4, 5, 6, 7, 8 y 9. Si deseáramos comenzar
desde el 1 e incluir el 10, cambiaríamos por

for ciclo in range(1, 11):

print(ciclo)

Cómo podríamos modificar este código para imprimir solo el valor final de la sumatoria entre
1 y 10? (55).
Estructuras de Control. Sentencias condicionales.

Si bien los primeros ejercicios de programación se presentan siempre muy básicos y

secuenciales, es decir, el sistema ejecuta determinada instrucción, luego otra, otra, y así
hasta finalizar con la última listada, rápidamente aparecerá la necesidad de evaluar
condiciones.

Desde el momento en el que incorporemos la capacidad de evaluar condiciones, podremos

“decidir” si se debe ejecutar determinado paquete de instrucciones u otro, de acuerdo a esas
condiciones. En otras palabras, ya no estaremos limitados a ejecutar secuencialmente un
solo paquete de instrucciones, sino que podremos ejecutar selectivamente ciertos comandos
solo cuando se cumplan determinadas condiciones.

Volviendo al ejemplo sencillo anterior, de imprimir mediante un ciclo los números del 1 al 10,
vamos a modificarlo ahora para imprimir solo los pares. Podremos aprovechar la misma
base de código, pero tendremos que incorporar una condición que nos permita evaluar si el
número actual es par o impar, para “decidir” si debemos imprimirlo o no. Entonces:

for ciclo in range(1, 11):

if (ciclo % 2 == 0)
print(ciclo)

Previamente la línea print(ciclo) se ubicaba directamente dentro del for(), es decir, era
ejecutada cada vez que el ciclo pasaba por allí. En este caso se ubica dentro de una
condición, por lo tanto en cada ciclo esa condición es evaluada -y solo si es verdadera- es
ejecutado el print().

El indicador % se denomina operador de módulo, y es un mecanismo práctico para

diferenciar números pares de impares. En este caso la expresión ciclo % 2 retorna el resto
de la división. Ya que un número par es perfectamente divisible por 2, no retornará resto,
entonces si ciclo % 2 es igual a 0, significa que ese número es par, caso contrario
lógicamente será impar.

El ciclo for() seguirá ejecutándose 10 veces (range(1, 11)), la condición if() será evaluada 10
veces, pero la instrucción print() solo será ejecutada cuando la condición devuelva un
resultado verdadero, y devolverá verdadero únicamente cuando ciclo % 2 sea 0.

Cómo podríamos modificar la condición para imprimir pero solo los impares?.
Así como podemos ejecutar un determinado paquete de instrucciones sólo si se cumple una
condición, es muy habitual tener la necesidad de ejecutar determinadas cosas al cumplirse,
y otras al no cumplirse. Si por ejemplo deseamos imprimir para cada número entre 1 y 10 si
es par o impar, podemos utilizar:

for ciclo in range(1, 11):

if (ciclo % 2 == 0):
print(“par”)
else:
print(“impar”)

Partiendo de estos ejemplos de referencia, ¿cómo reescribimos el código para contar la

cantidad de números pares y la cantidad de impares en un rango?.

No estamos limitados a utilizar condiciones únicas, cuando empleamos un if(), podemos

perfectamente combinar dentro varias condiciones, y utilizar operadores para definir si la
condición general será verdadera cuando algunas o todas las condiciones internas se
verifiquen. De forma similar, podemos “anidar” condiciones, es decir, generar una condición
if(), y dentro de ella (si es verdadera por ejemplo) otra condición if(), la cual lógicamente sólo
se evaluará si la primera es verdadera.

Veremos un detalle de operadores para tener una mejor referencia, y retomaremos luego
con otro ejemplo para ver esta situación.

Operadores aritméticos

Los operadores aritméticos son los que estamos más habituados a observar cotidianamente,
por su utilización en Matemática. Obviamente son también fundamentales al momento de
escribir código. Tenemos entonces:
● +: suma
● -: resta
● *: multiplicación
● /: división

Y otros como
● //: división entera
● %: módulo (resto de la división)
● **: exponencial (número elevado a la potencia)
Los primeros 4 no requieren demasiada presentación, son los que aplicamos habitualmente
desde pequeña edad para distintas operaciones sobre números. El orden de prioridades es
el que hemos aprendido desde chicos en Matemática, es decir, si en una operación tenemos
sumas o restas, y multiplicaciones o divisiones:
● Primero se ejecutan multiplicaciones y divisiones.
● Luego sumas y restas.

calculo = 8 / 2 + 4 * 3
calculo = 4 + 12
calculo = 16

Si solo tenemos sumas y restas, o multiplicaciones y divisiones, se ejecuta de izquierda a

derecha:

calculo = 20 - 3 + 17
calculo = 17 + 17
calculo = 34

El operador de división entera (//), funciona de la misma manera a la división tradicional,

pero retorna solamente la parte entera del resultado de la operación, es decir:

print(3 / 2) imprimirá 1.5

print(3 // 2) imprimirá 1

Al operador de módulo (%) ya lo hemos aplicado en algunas condiciones, retorna el resto de

la operación de división. Recordar que es muy utilizado para discernir entre números pares e
impares; cuando el número es perfectamente divisible por 2, % retornará cero, ejemplo:

print(7 % 2) imprimirá 1, porque 7 / 2 en entero sería 3 con un resto de 1, => módulo 1

Operadores relacionales

Los operadores relacionales esencialmente son símbolos que nos permiten comparar
valores. Ya hemos utilizado uno de ellos en los ejemplos de arriba, al escribir:

if (ciclo % 2 == 0)
(si la división por 2 de ciclo es igual a 0)

== es un operador relacional que significa “igual a”. Colocar == no es un error de tipeo, al

momento de evaluar condiciones se duplica el símbolo =, para diferenciarlo de la asignación.
Si deseamos asignar el valor 0 a ciclo, colocamos tan solo ciclo = 0 (como hemos aprendido
al momento de declarar variables), pero dentro de una condición, para evaluar si ciclo es o
no cero, colocamos ciclo == 0.

Los operadores relacionales son:

● ==: igual a
● !=: distinto a
● >: mayor a
● >=: mayor o igual a
● <: menor a
● <=: menor o igual a

Con ellos podemos armar de forma sencilla diferentes tipos de condiciones. Supongamos
que recibido un número, deseamos evaluar si es negativo, positivo o cero:

numero = 20

if (numero == 0):
print(“es cero”)
elif (numero > 0):
print(“es positivo”)
else:
print(“es negativo”)

Utilizamos el operador ==, de la misma forma que los ejemplos anteriores, pero ahora
aplicamos además el operador >, para determinar si el número es positivo.

Operadores lógicos

En complemento con los operadores relacionales, aparecen los operadores lógicos, que nos
permiten “encadenar” diferentes condiciones para ser evaluadas en conjunto, siguiendo la
lógica Booleana. La principal ventaja de esta situación es lograr un código más limpio y
organizado.

Los operadores booleanos utilizan la lógica de las compuertas habituales:

● and: y.
● or: o.
● not: no (negación).
También pueden utilizar otras combinaciones:
 ● nand (and negada)
● nor (or negada)
● xor (or exclusiva)

Podemos ver el resultado de las salidas en las 3 compuertas básicas (OR, AND y NOT):

Compuerta OR
E1 E2 S
0 0 0
0 1 1
1 0 1
1 1 1

Compuerta AND
E1 E2 S
0 0 0
0 1 0
1 0 0
1 1 1

Compuerta NOT
E S
0 1
1 0

Supongamos que deseamos determinar si un número es negativo, cero o positivo, y en caso

de ser positivo, si es o no mayor a 1000:

numero = 500

if(numero == 0):
print(“Es 0”)
elif(numero < 0):
print(“Es negativo”)
else:
if(numero > 1000):
print(“Es positivo y mayor a 1000”)
else:
print(“Es positivo pero no mayor a 1000”)
En este ejemplo tenemos una “anidación” de condiciones (unas dentro de otras); un primer
if() para determinar si el número es 0, negativo o positivo, y un segundo if() dentro de la
condición de positivo, para saber si es mayor a 1000 o no.

Si bien el ejemplo es funcional, aprovechando los operadores booleanos podemos escribirlo

de forma diferente y facilitar la lectura de código:

numero = -120

if(numero == 0):
print(“Es cero”)
elif(numero < 0):
print(“Es negativo”)
elif(numero > 0 and numero > 1000):
print(“Es positivo y mayor a 1000”)
else:
print(“Es positivo pero no mayor a 1000”)

Ahora obtendremos la misma funcionalidad, pero sin “anidar” ningún if(), manteniendo un
solo nivel con 4 posibles situaciones:
- Si el número es 0, será verdadera la primer situación, sino
- Si el número es < 0, será verdadera la segunda, sino
- Si el número es > 0 y además > 1000, será verdadera la tercera, sino
- Si el número no es 0, ni tampoco < 0, ni tampoco > 0 y a 1000, entonces la única
situación restante es que sea > 0 pero no a 1000, por esa causa la última opción solo
utiliza un else:, no es necesario en ese caso volver a revisar condiciones, si no se ha
validado ninguna de las 3 primeras, forzosamente el número será positivo pero no
mayor a 1000.

El hecho de hacer un uso mayor o menor de operadores booleanos, depende netamente de

las condiciones específicas que necesitemos verificar. Si son condiciones muy sencillas, no
serán imprescindibles, pero en combinaciones más complejas de condiciones, sí serán muy
útiles para mantener un código más legible y con menos anidación.

Importante!: los operadores aritméticos no cambian de un lenguaje a otro, pero los

relacionales y booleanos sí pueden expresarse de diferentes maneras. En nuestro caso
basamos los ejemplos en lenguaje Python, si queremos evaluar si un número es mayor a
cero y menor a 100, escribimos:

if(numero > 0 and numero < 100):

Esta misma condición expresada en C/C++, sería:

if(numero > 0 && numero < 100) {

Como este ejemplo, existen otros, el operador != (distinto a), se utiliza de la misma forma en
Python o C/C++, pero puede expresarse distinto en otros lenguajes, por ejemplo con el
símbolo <>.
No obstante, como podemos ver, la estructura básica de la condición se mantiene, salvo
detalles de sintaxis y el símbolo empleado para el operador, por lo cual bastará con estar
atento según sea el lenguaje utilizado y aplicar los símbolos correspondientes. De no
hacerlo, el compilador o el intérprete según el caso, generarán un error.

Expresiones

Muchas veces, cuando tenemos necesidad de trabajar con condiciones complejas, el código
puede volverse más incómodo de leer. Cuando asignamos variables, no estamos limitados a
asignar solamente valores específicos, podemos también asignar expresiones que se
resolverán en tiempo de ejecución, dando a la variable el valor correspondiente. Por
ejemplo, en la situación de arriba, donde colocamos la condición:

if(numero > 0 and numero < 100):

podríamos hacer lo siguiente:

numeroEnRango = numero > 0 and numero < 100

if (numeroEnRango == True):
## Ejecutar lo que corresponda

Como vemos, la expresión que antes se encontraba dentro de la condición (if), ahora está
asignada a una variable, y esta variable es la que se verifica en la condición. Este
mecanismo de expresiones no se emplea de forma constante en la práctica, pero en
algunos casos puede resultar de mucha utilidad para “limpiar” el código y permitir visualizar
con más claridad las condiciones.