Fundamentos de la Programación

#02 – Tipos de Datos

Después de realizar una pequeña introducción a la programación, llega el momento de comenzar a adentrarnos en ella. Y lo primero de lo primero, es conocer qué tipos de datos nos ofrece Python, además de los operadores para jugar con ellos.

Principales Tipos de Datos

Python (al igual que la mayoría de lenguajes de programación) posee una rica variedad de tipos de datos para que el desarrollador haga uso de ellos. Pero por el momento, vamos a centrarnos en los más básicos, y de ser necesario aprender alguno más lo veremos llegado el momento. Estos tipos de datos (comunes entre la mayoría de lenguajes) son: los números (tanto enteros como flotantes), los booleanos, y las cadenas.

Números Enteros

Estos enteros sí que molan, ¿eh?

Lo primero y más fundamental para programar son los número enteros (porque nos guste o no, programar implica matemáticas). Es un tipo de datos que todo el mundo conoce. Y, obviamente, sus principales operadores son la suma (+), la resta (-), el producto (*) y la división (/). Veamos un ejemplo de los mismos en Python:

>> 5 + 5 
10
>> 3 – 6 
-3
>> 10 * 5 
50
>> 7 / 2 
3

Un momento, para el carro. ¿Siete dividido entre dos es igual a tres? Pues por muy raro que parezca, así es. En Python, el resultado de dividir dos enteros también ha de ser un entero, por lo que se pierde la parte decimal. Si no queremos que eso ocurra, la solución que tenemos es utilizar números flotantes.

Números Flotantes

Como hemos comentado, los números flotantes son aquellos que poseen parte decimal. En Python la coma es representada mediante un punto (.), y el intérprete reconocerá como flotante cualquier número que haga uso de ella. Además, para asegurar el resultado, siempre que algún miembro de la operación sea un número flotante, el resultado de la misma también lo será, aunque se trate de un número entero. Recuperando el ejemplo anterior, ahora tenemos que:

>> 7.0 / 2.0 
3.5
>> 7.0 / 2 
3.5

Llegados a este punto, a la mayoría de la gente se le viene a la cabeza la misma pregunta: ¿por qué no utilizar siempre número flotantes? A fin de cuentas, de esa forma nos ahorraríamos posibles problemas por la perdida de parte decimal. Pues resulta que los enteros ocupan menos memoria, además de que las operaciones entre enteros suelen ser, por norma general, más rápidas (con el incremento de eficiencia correspondiente). Por lo tanto, sólo deberíamos utilizar número flotantes cuando de verdad necesitemos números con decimales.

Ademas de todo lo expuesto, hay que prestar especial atención al orden de prioridad entre las operaciones. De la misma forma que en las matemáticas comunes, el producto y la división tienen prioridad sobre la suma y la resta. Si no vamos con ojo, podría ocurrir lo siguiente:

>> 2.0 + 5 / 2
4.0

Podemos observar que la operación de división ha sido la más prioritaria, y como estaba formada por dos números enteros, el resultado también lo ha sido. Eso nos ha llevado a que al final la operación haya sido incorrecta, ya que se ha perdido la parte decimal. Una buena práctica para evitar esto es definir siempre el operando flotante en la división (5 / 2.0, por ejemplo).

Booleanos

Los booleanos son los tipos de datos lógicos (reciben ese extraño nombre a casa del Álgebra de Boole), y consisten en dos valores únicamente: True (verdadero) y False (falso). Existen tres operadores para trabajar con ellos:

  • Operador and, que devuelve True si y sólo si sus dos operandos son True.
  • Operador or, que devuelve True si cualquiera de sus dos operandos es True.
  • Operador not, que devuelve True si el valor es False; o False si el valor es True.
>> True and True 
True
>> True and False 
False
>> False or True 
True
>> not True 
False

Al igual que con los números, al trabajar con los operadores lógicos hemos de tener en consideración la prioridad de los mismos: not > and > or. Quizás se entienda mejor con un ejemplo:

Resolver sentencias lógicas en forma de árbol suele ser lo típico.

Ahora que ya conocemos los booleanos, podemos añadir nuevos operadores para los datos numéricos. Se trata de los operadores de comparación == (igualdad), > (mayor que), < (menor que), >= (mayor o igual que), <= (menor o igual que) y != (distinto). Un ejemplo:

>> 1 == 2 
False
>>3 == 2+1 
True
>> 3 != 2 
True
>> 5 >= 10 
False

Estos valores para los operadores lógicos aparecieron en los lenguajes de programación «modernos», aunque, por herencia con los lenguajes de programación más antiguos, podemos utilizar la sintaxis previa para realizar las mismas operaciones. Por ello, podemos realizar las siguientes identificaciones, que son conocidos como operadores binarios (porque para realizar la operación utilizan la representación en binario del valor indicado):

  • 0 como valor para False.
  • 1 como valor para True.
  • & como operador para and.
  • | como operador para or.
  • ~ como operador para not.

Cadenas

Pues ya conocemos los datos numéricos y todas sus posibilidades. No obstante, simplemente con ellos resultaría imposible la comunicación máquina-usuario. Para facilitar dicha comunicación se creo el tipo cadena (string), el cual consiste en una secuencia de caracteres de 0 o más elementos.

Las cadenas están formadas de caracteres.

Una cadena se distingue porque su valor va entrecomillado, ya sea por comillas simples o dobles. Las secuencias ‘Hola’ o «123» serían cadenas. El operador más básico para cadenas es la concatenación (+). Otro operador curioso es la repetición (*).

>> “Hola” + ”Adios” 
HolaAdios
>> “Hola” + “ “ + “Adios” 
Hola Adios
>> “5” + “5” 
55
>> “Hola” * 5 
HolaHolaHolaHolaHola

Los operadores de comparación también son compatibles con las cadenas. En este caso, los operadores == y != compararán ambas cadenas carácter a carácter para determinar si son iguales o no. Los operadores de menor y mayor, determinarán su resultado por su orden alfabético, o en caso de tratarse de caracteres que no pertenezcan al alfabeto, mediante su posición en la tabla ASCII.

>> “Hola” == “Adios” 
False
>> “antes” > “despues” 
False

Variables

Pues ya conocemos los tipos de datos básicos de Python y como manejarnos con ellos. Pero claro, tener que escribir cada vez el valor de los mismos cuando queramos usarlos puede llegar a ser un engorro. Por suerte, contamos con el concepto de variable. Una variable nos permite guardar en memoria el valor de un operando, para así poder utilizarlo de nuevo siempre que queramos. Para guardar un valor dentro de una variable, hacemos uso del operador de asignación (=), el cual siempre debe usarse a la derecha de la variable.

>> pi = 3.14 
>> pi 
3.14
>> pi * 2 
6.28
>> pi = 3 
>> pi 
3
>> pi * 2 
6

El nombre por el que nos referimos a una variable (en el ejemplo pi) se conoce como identificador. Este identificador nunca podrá coincidir con las palabras reservadas del lenguaje que estemos utilizando. En Python, estas palabras son: and, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is, lambda, not, or, pass, print, raise, return, try, while y yield.

Entrada y Salida

Vale, recapitulemos. Ya sabemos operar con los datos básicos. Ya sabemos almacenar los valores obtenidos para no haber trabajado en balde. ¿Qué nos falta? Pues comunicarnos con ese usuario que se encuentra al otro lado de la pantalla. Para ello, Python cuenta con diversas funciones de entrada y salida (de datos).

Para mostrar datos por pantalla, utilizaremos la función print. Su sintaxis es la siguiente:

print(variable1, variable2, ...)

Para obtener datos del usuario, utilizaremos la función input. Su sintaxis es la siguiente:

varaible = input(cadena)

¡Ojo! La función input siempre devuelve (con devolver nos referimos al valor que es asignado a la variable asociada) una cadena, por lo que si queremos utilizarla como un número, hay que convertirla previamente utilizando las funciones int() para enteros y float() para flotantes. Veamos el ejemplo mostrado en el capítulo anterior:

a = float(input("Operando A: "))
b = float(input("Operando B: "))
c = (a + b)/2
print("La media es: ", c)

La primera y la segunda línea, solicitan al usuario un valor (el cual se le especifica mediante una cadena de texto informativa) y se almacenan en sus respectivas variables. La tercera línea calcula la media de dichos valores (prestad atención a los paréntesis para modificar la prioridad de los operadores). Finalmente, en la cuarta linea, se le muestra el resultado al usuario, precedido este por una variable de tipo cadena (no almacenada en memoria) que le aporta contexto al valor mostrado.


Con esto terminamos este capítulo dedicado a los Tipos de Datos. Ahora, si te sientes preparado, puedes realizar el Ejercicio 1 de los Ejercicios del Curso. En la próxima entrada, comenzaremos a ver las Estructuras de Control.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

back to top