2.3.- 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.