Tipos de datos; Números, Booleanos y Cadenas

En este video continuaremos analizando nuestro programa de ejemplo y conoceremos los diferentes tipos de datos que nos ofrece Python.

Si continuamos analizando nuestro programa, veremos la expresión CONDICIONES = {…}. ¿Qué sucede aquí? En esta instancia se está creando nuestra primer variable, aunque para ser más exactos, es -por convención- una constante. Pero ahora, ¿qué son las variables y las constantes?

Una variable es un espacio en memoria que guarda un valor determinado y permite obtener y/o modificar su valor en cualquier instancia del código. Cada variable tiene un nombre, un tipo de dato y un valor.

Una constante es algo similar a una variable, pero está pensado para almacenar valor o valores que no serán modificados.

Si vienes de otro lenguaje de programación, quizás te preguntes ¿qué tipo de dato es esta constante? ¿Por qué si es una constante no se la especifica como tal? No te preocupes, hay respuesta a todo ello.

Si aún lo recuerdas, Python es un lenguaje de tipado dinámico, por lo que no es necesario que especifiques el tipo de dato que almacena una variable y los tipos de datos más importantes de Python son:

• Números: Pueden ser enteros (1, 2, 3,…) o flotantes (1.1, 1.2…).
• Booleanos: Su valor puede ser únicamente True o False.
• Cadenas: Son secuencias de caracteres Unicode, por ejemplo, una palabra, una frase o un documento HTML, etc.
• Listas: Son secuencias de valores ordenados guardados en un mismo contenedor.
• Tuplas: Son secuencias de valores ordenados inmutables guardados en un mismo contenedor.
• Conjuntos: Son “contenedores” de valores sueltos sin ordenar.
• Diccionarios: Son conjuntos sin ordenar en formato de parejas clave: valor. En los diccionarios es posible acceder a un valor por su clave.

Demos un repaso a estos tipos de datos.

Números

Python proporciona número enteros y de punto flotante (decimales) pero no existen declaraciones para diferenciarlos; Python los distingue por la presencia del punto decimal.

Para crear una variable en Python, solamente debes indicar su nombre, el signo igual y luego indicar el valor que deseas almacenar, así de simple. Por ejemplo..

>>> PI = 3.14159
>>> type(PI)
<class 'float'>
>>> isinstance(PI, float)
True
>>> radio = 5
>>> type(radio)
<class 'int'>
>>> superficie = (radio ** 2) * PI

1. Creamos una constante de nombre PI con valor 3.14159. Aunque en Python, no existen las constantes como tal, dado a que por definición, las constantes no pueden ser modificadas luego de la primera asignación, pero por convención, se entiende que todas las variables cuyos nombres se encuentran en mayúsculas, deberían ser constantes.
2. Luego utilizamos la función type() que es propia del lenguaje y permite consultar el tipo de dato de un valor o variable.
3. Como podemos ver en este caso, la constante PI es un número flotante.
4. También podemos utilizar la función isinstance(), que permite verificar si un valor o una variable es de un tipo de dato específico. Al evaluar si PI es un número flotante, devuelve que es Verdadero.
5. Por último, creamos la variable superficie en la cual se elevamos el valor de radio al cuadrado con el operador ** y luego lo multiplicamos por la constante PI.

En Python es posible convertir un entero a flotante y un flotante a un entero. Por ejemplo…

>>> int(3.14159)
3
>>> float(5)
5.0
>>> 1.12345678901234567890
1.1234567890123457
>>> type(1000000000000000)
<class 'int'>

1. Con La función int() convertimos el valor pasado como parámetro a un entero. En caso de ser un valor flotante, se trunca -es decir que se omite- la parte decimal.
2. Al utilizar la función float() podemos convertir un valor entero a un valor flotante.
3. Al ingresar un valor con muchos decimales (más de 15), solo se muestran 15 de ellos, debido a que la precisión de los números flotantes en Python es de 15 posiciones decimales.
4. Los enteros en Python 3 no tienen un límite de tamaño, por lo que no existe el tipo de dato long. Si quieres mayor detalle. Puedes obtener más detalle de esto en el PEP237.

Operadores numéricos

Los operadores más sencillos que encontrarás en Python, al igual que en la mayoría de lenguajes de programación son la Suma, Resta, Multiplicación, División, Exponente, División entera y Resto o Módulo. Vemos algunos ejemplos…

>>> 3 + 2.0
5.0
>>> 4 - 7
-3
>>> 2 * 6
12
>>> 3.5 / 2
1.75
>>> 5 ** 2
25
>>> 5.25 // 2
2.0
>>> 5 % 2
1

1. Si Sumamos un valor entero con un flotante, dará como resultado un flotante.
2. Podemos ver que los número enteros también pueden almacenar números negativos.
3. Al realizar la operación // devuelve únicamente la parte entera de la división, pero como un flotante.
4. El operador % devuelve el resto -o módulo- de la división realizada.

La historia no termina aquí. En Python puedes utilizar muchos más tipos de datos para operaciones más complejas, como trigonometría, fracciones, etc. Si ese es tu caso, puedes investigar los módulos math y fractions.

Booleanos

Los booleanos sólo poseen dos valores posibles: Verdadero o Falso. Python posee dos constantes para asignar estos valores: True y False.

El tipo de dato bool hereda de los enteros, por lo que pueden tratarse como si fueran números, donde True es 1 y False es 0. De hecho, podemos comprobarlo:

>>> type(True)
<class 'bool'>
>>> isinstance(True, int)
True

1. Si comprobamos el tipo de datos de True, indica que es un bool
2. Pero si evaluamos si True es una instancia de int, también devolverá True.

Vale aclarar que esto es meramente informativo y utilizar las constantes True y False como enteros está completamente mal visto, nunca lo hagas!

En ciertos lugares (como las sentencias if) no es necesario que evalúes una condición a True, dado a que Python espera por una una expresión que pueda evaluarse a un valor booleano. Estos se llaman “contextos booleanos”. Vale aclarar que cada tipo de dato tiene sus reglas para determinar si un valor equivale a verdadero o falso. Por ejemplo…

>>> valor = 1
>>> valor < 0
False
>>> valor = 0
>>> valor < 0
False
>>> valor = -1
>>> valor < 0
True

1. Si creamos una variable de valor 1.
2. Y evaluamos si es menor a cero, devolverá False.
3. Si definimos que es cero y volvemos a evaluar.
4. Volverá a dar False.
5. Si definimos que el valor es menos 1 y volvemos a evaluar
6. Devolverá True.

En estos ejemplos solo hemos comparado si la variable valor es menor a cero. Más adelante veremos más sobre comparadores lógicos.

Cadenas

En Python también es posible manipular cadenas de texto y pueden ser declaradas de distintas maneras, tanto con comillas simples ‘…’ o con comillas dobles “…”; ambas tienen el mismo resultado. Por ejemplo…

>>> mensaje = "Hola, esto es una cadena"
>>> saludo = 'Hola, esto es otra cadena'
>>> type(mensaje)
<class 'str'>
>>> type(saludo)
<class 'str'>

1. Creamos una variable mensaje con el valor “Hola, esto es una cadena” utilizando comillas dobles.
2. Luego creamos una variable saludo con el valor “Hola, esto es otra cadena”, pero utilizando comillas simples.
3. Si obtenemos el tipo de dato de ambas variables, dará el mismo resultado: str.

Para poder utilizar caracteres especiales en las cadenas, como el mismo caracter con el que la creaste o un salto de línea, etc, se utiliza el caracter barra invertida (\). Por ejemplo…

>>> cita = "\"Sí\", le dijo."
>>> print(cita)
"Sí", le dijo.
>>> lineas = "Esto es la linea 1. \nEsto es la linea 2."
>>> print(lineas)
Esto es la linea 1.
Esto es la linea 2.

1. Creamos la variable cita con dobles comillas y entrecomillamos la palabra Si.
2. Si imprimimos el valor, vemos que fue correcto.
3. Creamos otra variable línea utilizando el caracter \n para indicar un salto de línea.
4. Si imprimimos el valor, vemos que se creó correctamente.

Si no deseas que los caracteres antepuestos por la barra invertida sean caracteres especiales, puedes usar cadenas crudas, utilizando la letra r antes de la primer comilla. Como por ejemplo…

>>> print(r'C:\algun\nuevo\directorio')
C:\algun\nuevo\directorio

1. Utilizamos la función print y pasamos una cadena cruda.
2. El caracter \n es ignorado y se lo considera.

Además, las cadenas pueden ser concatenadas con el operador + y repetidas con *. Por ejemplo…

>>> " sonó" * 3 + ", me llaman del bar de Moe."
' sonó sonó sonó, me llaman del bar de Moe.'

1. Multiplicamos la cadena “sonó” por 3 y luego sumamos otra cadena.
2. Vemos que la salida incluye “sonó” 3 veces.

Las cadenas también pueden ser indexadas, es decir que puedes acceder a una posición específica de ellas comenzando en la posición 0 para el primer caracter. Por ejemplo…

>>> leguaje = "Python"
>>> lenguaje[0]
'P'
>>> lenguaje[-1]
'n'
>>> lenguaje[0:2]
'Py'

1. Creamos la variable lenguaje con el valor Python.
2. Accedemos a la posición cero de la cadena y observamos que es el primer caracter.
3. …
4. Para acceder al último caracter, puedes utilizar la posición -1.
5. …
6. Para obtener una porción de la cadena, puedes hacerlo indicando la posición inicial, dos puntos y la posición final, sin incluir la misma.

Hay mucho más cosas que puedes lograr con cadenas, pero hablaremos más de ellos en el siguiente módulo.