Tipos de datos simples¶

Variables¶

Una variable es una etiqueta que le ponemos a un dato o valor para identificarle.

1 2	`mensaje = "Hola mundo!" print(mensaje)`

En el ejemplo, guardamos la cadena de texto en una variable llamada mensaje. El operador = almacena el valor de la derecha en la variable de la izquierda. A partir de ese momento, al utilizar el nombre de la variable en cualquier lugar del código, estaremos indicando que realmente queremos utilizar el valor o dato que contiene (o al que apunta si pensamos en una variable como una etiqueta).

Nombrar variables¶

A la hora de nombrar variables existen algunas reglas de obligado cumplimiento:

Los nombres de variables solamente pueden contener letras, números y guiones bajos. Pueden empezar con una letra o un guión bajo pero no pueden empezar por un número.
No se pueden utilizar como nombres de variables palabras claves de Python o nombres de funciones (palabras reservadas).

También existen algunas recomendaciones que es importante seguir:

Utilizar nombres de variables en minúsculas.
Cuando el nombre de una variable esté formado por varias palabras, separar estas por un guión bajo.
Los nombres de las variables deben ser cortos y descriptivos evitando en lo posible el uso de abreviaturas.

Tipo de una variable¶

Podemos consultar cual es el tipo almacenado en una variable con la función type(variable).

a = 10
b = 10.0
c = "10"
print(type(a))
print(type(b))
print(type(c))

<class 'int'>
<class 'float'>
<class 'str'>

Tipo String¶

Un string es una serie ordenada de caracteres (letras, números y/o signos de puntuación). Para indicar que un valor es un string utilizaremos comillas dobles o comillas simples para delimitarlo.

1 2	`print("Esto es un string") print('Esto también es un string')`

Esto es un string
Esto también es un string

Un string puede no contener ningún carácter y estar vacio, por ejemplo: nombre = "".

Podemos utilizar comillas triples para crear strings que ocupen múltiples líneas.

mensaje = """Esto es un
texto que
    ocupa tres líneas"""
print(mensaje)

Esto es un
texto que
    ocupa tres líneas

Podemos concatenar strings con el operador +. Podemos obtener la longitud de un string con la función len(variable). Podemos acceder a un caracter de un string a través de su índice utilizando corchetes variable[i]. Hay que tener presente que se empieza a contar por 0 luego el primer caracter está en la posición cero.

palabra1 = "Pay"
palabra2 = "Pal"
marca = palabra1 + palabra2
print(marca)
print(len(marca))
print(marca[2])

PayPal
6
y

Podemos utilizar el operador * para repetir un string varias veces.

1 2	`print('' 7) print('Yes' * 5)`

*******
YesYesYesYesYes

Con los operadores "igual a" == y "distinto de" != podemos comparar si dos datos de tipo string son iguales. Dependiendo de si se cumple o no la condición, obtendremos un True o un False. En las comparaciones hay que tener presente que las letras máyusculas son diferentes que las minúsculas.

print('Audi' == 'Audi')
print('Audi' == 'BMW')
print('Audi' != 'BMW')
print('Audi' == 'audi')

True
False
True
False

Métodos disponibles¶

Una variable que contiene un tipo de dato string tiene disponibles una serie de métodos a los que podemos acceder escribiendo el nombre de la variable, un punto, el nombre del método y unos paréntesis (que solo contendran datos en su interior cuando el método específico lo requiera).

1 2	`mensaje = "Hola mundo!" print(mensaje.upper())`

En el ejemplo, el método upper devuelve el texto contenido en la variable mensaje en mayúsculas.

HOLA MUNDO!

Algunas de los métodos que podemos utilizar con una variable string llamada a son los siguientes:

a.upper() Devuelve el texto en mayúsculas.
a.lower() Devuelve el texto en minúsculas.
a.title() Devuelve el texto en minúsculas con la primera letra de cada palabra en mayúsculas.
a.isnumeric() Devuelve True si el valor es un número, en otro caso devuelve False.
a.rstrip() Elimina espacios en blanco (incluyendo tabulaciones y saltos de línea) de la derecha de un string.
a.lstrip() Elimina espacios en blanco (incluyendo tabulaciones y saltos de línea) de la izquierda de un string.
a.strip() Elimina espacios en blanco (incluyendo tabulaciones y saltos de línea) de ambos lados de un string.
a.split(caracter) Divide el string en varios trozos. Para ello utiliza el "caracter que le pasamos como separador."
a.count(texto) Cuenta cuantas veces "texto" esta contenido en el string. Texto es también un string.
a.replace(texto1, texto2) Reemplaza en el string texto1 por texto2.
a.find(texto) Obtiene el índice de la primera ocurrencia del "texto" en el string. Si no lo encuentra devuelve -1.

Veamos un ejemplo de algunos de ellos:

a = "Sun goes down.  "
print(a.upper())
print(a.lower())
print(a.title())
print(a.isnumeric())
print(len(a))
b = a.strip()
print(b)
print(b.split(' '))
print(b.count('n'))
print(b.replace('down', 'up'))
print(b.find('go'))

SUN GOES DOWN.  
sun goes down.  
Sun Goes Down.  
False
16
Sun goes down.
['Sun', 'goes', 'down.']
2
Sun goes up.
4

Una relación más exhaustiva de todos los métodos del tipo string se puede consultar aquí.

Formato usando variables¶

Para poder utilizar variables dentro de un string, colocaremos la letra f justo antes de las comillas iniciales que lo delimitan. De esta forma podremos incluir nombres de variables en el string ubicándolas entre llaves. Python sustituirá el nombre de la variable por el valor almacenado en ella a la hora de evaluar el string. Veamos un ejemplo:

1
2
3

nombre = "Al Pacino"
profesion = "actor"
print(f"{nombre} es un gran {profesion}")

Al Pacino es un gran actor

A este tipo de strings se les llama strings con formato o f-strings. Fueron introducidos por primera vez en la versión 3.6 de Python. En versiones anteriores no funcionan y era necesario utilizar la función format de la siguiente manera:

1	`print("{} es un gran {}".format(nombre, profesion))`

Entre las llaves y después del nombre de la variable podemos añadir el carácter : y, a continuación, indicar cuantas posiciones deseamos que ocupe nuestro dato y si queremos alinearlo a la derecha, a la izquierda o en el centro. Esto es muy útil para representar datos en formato de tabla.

a = 128
print(f"Dato|{a:<10}|")
print(f"Dato|{a:>10}|")
print(f"Dato|{a:^10}|")

Dato|128       |
Dato|       128|
Dato|   128    |

Si es un número, incluyendo una "coma" después de los "dos puntos" podemos indicar que deseamos incluir separadores de miles. Si incluimos un "punto" y un valor numérico indicamos el número de decimales que queremos. Incluyendo una "f", un "%" o una "e" indicamos si lo deseamos expresar como un número, en tanto por ciento o en notación científica respectivamente.

a = 130500.125
print(f"{a:,}")
print(f"{a:.2f}")
print(f"{a:.2e}")

130,500.125
130500.12
1.31e+05

También es posible incluir valores dentro de un string utilizando el símbolo especial %. Este símbolo actua como un comodín que posteriormente será sustituido por el valor indicado. El símbolo % actua como un prefijo para otro carácter que define el tipo de valor que se desea insertar.

1
2
3

nombre = "Miguel"
puntuacion = 875
print("Hola %s, tus puntos son %i de %i." % (nombre, puntuacion, 1000))

Hola Miguel, tus puntos son 875 de 1000.

En el ejemplo aparece un string que contiene tres comodines (%s, %i, %i). El primero indica que se insertará un dato de tipo string, los dos siguientes indican que se insertarán números enteros. Separado del string por el carácter % se indican los tres valores que deben de sustituir cada comodín, por orden. Los dos primeros son variables y el tercero es un valor numérico literal.

Plantillas usando variables¶

Otra alternativa para formatear strings no tan habitual es la utilización de plantillas (Templates). Fueron introducidas en Python 2.4 como una forma sencilla de proporcionar formato. Para utilizarlas hay que importar la librería string. Veamos un ejemplo:

import string

template = string.Template('$usuario ha $operacion $cantidad veces')
print(template.substitute(usuario='Miguel', operacion='guardado', cantidad=7))
print(template.substitute(usuario='Lucia', operacion='formateado', cantidad=2))

d = dict(usuario='Luis', operacion='borrado', cantidad=4)
print(template.substitute(d))

Miguel ha guardado 7 veces
Lucia ha formateado 2 veces
Luis ha borrado 4 veces

Se crea la plantilla con el método Template de la clase string. A ese método se le pasa un string que contiene comodines (variables que comienzan con el carácter $). Luego, utilizando el método substitute de la plantilla creada podemos sustituir los comodines por los valores que queramos. También es posible enviar al método substitute un diccionario que contiene dentro los pares clave/valor correspondientes.

Secuencias de escape¶

Existen ciertos caracteres especiales que no tienen una representación directa mediante un símbolo como, por ejemplo, una tabulación o un salto de línea. Para poder incluir estos caracteres en un string utilizaremos una barra inclinada seguida de una letra (a esto lo denominamos secuencia de escape). Dado que la barra inclinada sirve para iniciar una secuencia de escape, cuando queramos incluir el carácter barra inclinada en un string utilizaremos la secuencia de escape \\ (doble barra inclinada).

Las secuencias de escape más habituales son:

Secuencia	Nombre
\t	Tabulación
\n	Salto de línea
\r	Retorno de carro
\	Barra inclinada
\'	Comilla simple
\"	Comilla doble
\xhh	Caracter con valor hexadecimal hh

1	`print("Hola,\nnecesito\n\t\x7E Una palanca\n\t\x7E Un punto de apoyo")`

Hola,
necesito
    ~ Una palanca
    ~ Un punto de apoyo

Tipos numéricos¶

Podemos manejar tres tipos básicos de datos numéricos: número enteros (integer), números reales (float) y números complejos. Para los números reales utilizaremos el punto decimal a la hora de escribir valores literales en nuestro programa.

Operadores comunes¶

Los operadores más comunes son los siguientes:

Operador	Nombre
+	Suma
-	Resta
*	Multiplicación
/	División
//	División entera
%	Módulo
**	Exponente

Cuando en una operación solo intervienen enteros, el resultado es un número entero salvo que sea una división en cuyo caso será un numero real (salvo que el operador sea la división entera). Cuando en una operación intervienen enteros y reales el resultado siempre es un número real.

Veamos algunos ejemplos:

a = 9
b = 2
c = 0.1
print(a + b)
print(a - b)
print(a * b)
print(a / b)  # División entre enteros devuelve float
print(a // b) # División entera entre enteros devuelve int
print(a ** b) # a elevado a b
print(a % b)  # resto que queda de la división entera entre a y b
print(c + 0.2)

11
7
18
4.5
4
81
1
0.30000000000000004

Cabe destacar que, en ocasiones, por la forma en que se representan internamente los datos reales ocurren efectos como el que podemos apreciar en la última operación del ejemplo anterior.

Cuando en una expresión intervengan múltiples operandos y operadores y tengamos dudas sobre que operadores se ejecutan antes que otros podemos utilizar paréntesis para definir claramente que orden de ejecución necesitamos. Una regla útil es que la multiplicación y la división se ejecutan antes que la suma y la resta.

1 2	`print(2 + 10 / 2) print((2 + 10) / 2)`

7.0
6.0

Asignación¶

El operador de asignación = asigna el valor de su derecha a la variable de su izquierda. Existen otros operadores compuestos que simplifican operaciones de asignación. Por ejemplo, para sumar 1 al valor de una variable es común utilizar la siguiente expresión: x = x + 1. Esa misma expresión se puede escribir con un operador de asignación compuesto así: x += 1. Veamos una tabla con algunos de los operadores de asignación compuestos.

Suponiendo x = 10:

Operador	Ejemplo	Equivalente	Resultado
+=	x += 2	x = x + 2	12
-=	x -= 2	x = x - 2	8
/=	x /= 2	x = x / 2	5.0
//=	x //= 2	x = x // 2	5
%=	x %= 2	x = x % 2	0

Asignación múltiple¶

Es posible asignar valores a más de una variable en la misma línea utilizando el operador =.

1	`latitud, longitud = 43.404, -3.885`

Números largos¶

Cuando escribimos números muy largos se pueden utilizar guiones bajos para separar los grupos de miles y así hacer el número más legible. Esto no afecta al valor del dato, solamente es una cuestión estética.

1
2
3

fortuna_jeff_bezos = 117_000_000_000
edad_universo = 13_800_000_000
print(fortuna_jeff_bezos / edad_universo)

Constantes¶

Una constante es como una variable pero su valor no debe cambiar durante la ejecución de un programa. Python no tiene soporte nativo para constantes. Aún así, los programadores usan letras mayúsculas para indicar que una variable se debe tratar como una constante.

1	`DIAMETRO_TERRESTRE = 12742`

Números complejos¶

Los números complejos están formados por la suma de dos términos a + bi. El primer término es la parte real y el segundo es la parte imaginaria que consiste en un número real multiplicado por el valor de i (raiz cuadrada de -1). Python utiliza la letra j para representar la parte imaginaria de un número complejo. Veamos un ejemplo:

c = 3+2j
print(type(c))
print(c.real)
print(c.imag)
print(c)

<class 'complex'>
3.0
2.0
(3+2j)

Conversión de tipos¶

Para convertir un dato a otro tipo utilizaremos las siguientes funciones:

Función	Conversión
str	Convierte a string
int	Convierte a entero
float	Convierte a float
complex	Convierte a complejo
bool	Convierte a booleano

a = "1"
print(type(a))
b = float(a)
print(type(b))
print(b)

<class 'str'>
<class 'float'>
1.0

Tipo Booleano¶

Un tipo de dato booleano solo puede tener dos valores: True o False. Podemos convertir enteros a booleanos siendo 0 False y 1 True. También podemos convertir strings siempre que los valores que contengan sean "True" y "False".

abierto = True
print(type(abierto))
print(abierto)
print(int(abierto))
print(bool(0))

<class 'bool'>
True
1
False

El tipo None¶

Python tiene un tipo especial denominado NoneType que solo admite un valor: None. Se utiliza para representar valores nulos o, visto de otra forma, la ausencia de valor. Podemos utilizarlo para crear una variable cuando aún no tenemos un valor para ella.

Podemos consultar cuando una variable contiene el valor None con las expresiones variable is None o variable is not None.

usuario = None
print('usuario:', usuario)
print('tipo:', type(usuario))
print('usuario es nulo:', usuario is None)
print('usuario no es nulo:', usuario is not None)

usuario: None
tipo: <class 'NoneType'>
usuario es nulo: True
usuario no es nulo: False

Pedir datos por Consola¶

La función input permite pedir datos al usuario por Consola.

Ejecutar 'input' en Sublime Text

Si estamos ejecutando nuestros programas desde Sublime Text la función input no funcionará por defecto. Deberemos ejecutar el programa directamente desde la Consola de Windows con el comando python nombre_archivo.py. Otra opción es instalar un paquete de Sublime Text llamado SublimeREPL siguiendo las instrucciones de esta página. Un vez instalado, ya podremos ejecutar programas que hagan uso de input desde el menú Tools > SublimeREPL > Python > Python - RUN current file.

Podemos pasar a input un argumento que contenga el mensaje que deseamos mostrar al usuario para pedir el dato. La función input devuelve siempre un dato de tipo string. Si queremos tratarlo como un número para operar con el tendremos que realizar una conversión al tipo correspondiente con las funciones int o float.

nombre = input("¿Como te llamas? ")
edad = int(input("¿Cuantos años tienes? "))
peso = float(input("¿Cuanto pesas (en kg)? "))
altura = float(input("¿Cuanto mides (en m)? "))
imc = peso / altura ** 2
print(f"Hola {nombre}. Tu indice de masa corporal es de {imc:.2f}")

¿Como te llamas? Jason
¿Cuantos años tienes? 53
¿Cuanto pesas (en kg)? 84
¿Cuanto mides (en m)? 1.78
Hola Jason. Tu indice de masa corporal es de 26.51