Guía de tipos de datos básicos en Python con ejemplos

En este tutorial, nos sumergiremos en los tipos de datos básicos en Python, como int, float, str, bool y duct. También cubriremos ejemplos de su uso y algunas advertencias.

Introducción a los tipos de datos de Python

En este artículo, nos sumergiremos en los Tipos de datos básicos en Python. Estos forman algunas de las formas fundamentales en que puede representar datos.

Una forma de categorizar estos tipos de datos básicos es en uno de cuatro grupos:

  • Numérico: int, float y el complejo que se encuentra con menos frecuencia
  • Secuencia: str (cadena), lista y tupla
  • Booleano: (Verdadero o Falso)
  • Diccionario: tipo de datos dict(diccionario), que consta de pares (clave, valor)

Es importante señalar que Python generalmente no requiere que especifique qué tipo de datos está utilizando y asignará un tipo de datos a su variable en función de lo que cree que quiso decir.

Una cosa igualmente importante para señalar es que Python es un lenguaje de programación "vagamente/débilmente tipado", lo que significa que una variable puede cambiar su tipo en el transcurso de la ejecución del programa, que no es el caso con Lenguajes de programación "fuertemente tipados" (como Java o C++).

Así que algo que era un int puede terminar siendo un str fácilmente, si le asignas un valor de cadena.

En nuestros ejemplos, ocasionalmente usaremos una función llamada tipo (variable) que devuelve, bueno, el tipo de la variable que le pasamos.

También usaremos el shell de Python para que no tengamos un código engorroso para imprimir todo lo que queremos mostrar.

Tipos de datos numéricos

Estos tipos de datos son bastante sencillos y representan valores numéricos. Estos pueden ser valores decimales, valores de punto flotante o incluso números complejos.

Tipo de datos enteros - int

El tipo de datos int trata con valores enteros. Esto significa valores como 0, 1, -2 y -15, y no números como 0.5, 1.01, -10.8, etc.

Si le das a Python el siguiente código, concluirá que a es un número entero y le asignará el tipo de datos int:

1
2
3
>>> x = 5
>>> type(x)
<class 'int'>

Podríamos haber sido más específicos y haber dicho algo similar, para asegurarnos de que Python entendiera nuestro 5 como un número entero, sin embargo, automáticamente hará exactamente lo mismo debajo del capó:

1
2
3
>>> x = int(5)
>>> type(x)
<class 'int'>

Vale la pena señalar que Python trata cualquier secuencia de números (sin prefijo) como un número decimal. Esta secuencia, de hecho, no está restringida.

Es decir, a diferencia de otros lenguajes como Java, el valor de int no tiene un valor máximo, es ilimitado.

sys.maxsize puede sonar contradictorio entonces, ya que implica que ese es el valor máximo de un número entero, aunque no lo es.

1
2
3
>>> x = sys.maxsize
>>> x
2147483647

Esto parece ser un valor entero binario con signo de 32 bits, sin embargo, veamos qué sucede si asignamos un número más alto a x:

1
2
3
>>> x = sys.maxsize
>>> x+1
2147483648

De hecho, incluso podemos llegar a:

1
2
3
>>> y = sys.maxsize + sys.maxsize
>>> y
4294967294

El único límite real de cuán grande puede ser un número entero es la memoria de la máquina en la que está ejecutando Python.

Prefijar enteros

¿Qué sucede cuando desea empaquetar un valor numérico en una forma diferente? Puede prefijar una secuencia de números y decirle a Python que los trate en un sistema diferente.

Más específicamente, los prefijos:

  • 0b o 0B - Convertirá su número entero en binario
  • 0o o 0O - Convertirá su número entero en Octal
  • 0x o 0X - Convertirá su número entero en hexadecimal

Entonces, probemos estos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
# Decimal value of 5
>>> x = 5
>>> x
5

# Binary value of 1
>>> x = 0b001
>>> x
1

# Octal value of 5
>>> x = 0o5
>>> x
5

# Hexadecimal value of 10
>>> x = 0x10
>>> x
16

Tipo de datos de punto flotante - float

El tipo de datos float puede representar números de punto flotante, hasta 15 lugares decimales. Esto significa que puede cubrir números como 0.3, -2.8, 5.542315467, etc. pero también enteros.

Los números que tengan más de 15 números después del punto se truncarán. Por ejemplo, Python no tiene dificultad para entender correctamente lo siguiente como un flotador:

1
2
3
4
5
6
>>> y = 2.3
>>> type(y)
<class 'float'>
>>> y = 5/4
>>> type(y)
<class 'float'>

Sin embargo, como se mencionó anteriormente, si solo decimos 5, Python lo considerará un tipo de datos int. Si, por alguna razón, quisiéramos una variable flotante que tuviera el valor 5, tendríamos que informar explícitamente a Python:

1
2
3
4
5
6
>>> y = 5.0
>>> type(y)
<class 'float'>
>>> y = float(5)
>>> type(y)
<class 'float'>

Este tipo de datos se puede usar para representar algunos "números" especiales como NaN ("No es un número"), +/-infinito y exponentes:

1
2
3
4
5
6
7
8
9
>>> y = float('-infinity')
>>> y
-inf
>>> y = float(5e-3)
>>> y
0.005
>>> y = float('nan')
>>> y
nan

Una nota al margen interesante aquí es cómo se comporta NaN. Es decir, ejecutar y == float('nan') devolvería False, aunque y no es un número.

De hecho, su comportamiento puede verse como extraño al comparar los valores y las referencias:

1
2
3
4
5
6
7
>>> x = float('nan')
>>> x == float('nan')
False
>>> x == x
False
>>> x is x
True

Por supuesto, esto sucede porque NaN estaba destinado a comportarse de esta manera, pero sigue siendo interesante.

Si no está familiarizado con la diferencia entre los operadores == y is, consulte nuestra guía de [Comparación de objetos en Python - == vs es](/comparacion-de-objetos-is-vs- python/)!

Números complejos - complejo

El último tipo numérico que necesitamos cubrir es el tipo complejo. Es un tipo de dato raramente usado, y su trabajo es representar números imaginarios en un par complejo.

El carácter ‘j’ se usa para expresar la parte imaginaria del número, a diferencia de la ‘i’ que se usa más comúnmente en matemáticas.

Esto se debe a que Python sigue la práctica de la ingeniería eléctrica, en lugar de la práctica matemática de nombrar la parte imaginaria de un número complejo.

Veamos cómo podemos declarar números complejos en Python:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# Assigning a value of 0r and 1j to `com`
>>> com = 1j

# Printing `com`s value
>>> com
1j

# Multiplying complex numbers
>>> com*com
(-1+0j)

# Assigning a value to a new `com` number
>>> com2 = 3 + 1j

# Adding two complex numbers
>>> com+com2
(3+2j)

# Assigning a new value to `com`
>>> com = complex(1 + 2j)

# Printing `com`
>>> com
(1+2j)

Tipos de datos de secuencia

Los Tipos de datos de secuencia se utilizan para representar colecciones de algún tipo. Estas colecciones de elementos pueden consistir en elementos del mismo tipo o de tipos completamente diferentes.

calle

Las cadenas son secuencias de caracteres, representadas por comillas simples o dobles. Esto incluye cadenas vacías (sin caracteres entre comillas).

De manera similar a los números enteros, las cadenas realmente no tienen un límite de longitud establecido. Puede hacer una cadena siempre que la memoria de su computadora lo permita, técnicamente.

Las cadenas son muy comunes ya que son la forma más básica de representar una secuencia de caracteres o palabras:

1
2
3
4
5
>>> my_string = 'some sequence of characters'
>>> my_string
'some sequence of characters'
>>> type(my_string)
<class 'str'>

También pueden contener valores especiales, algunos de los cuales son \n si queremos que la cadena, cuando se imprima, tenga una nueva línea, o si queremos usar caracteres especiales como \, ' o " necesitamos agregar una barra invertida antes de ellos, por ejemplo, \.

Agregar una barra invertida antes de ellos es llamar a escapar los caracteres especiales, ya que no queremos que se tenga en cuenta su significado especial; queremos que se usen sus valores literales.

1
2
3
4
>>> my_string = "adding a new line \n and some double quotes \" to the string"
>>> print(my_string)
adding a new line 
 and some double quotes " to the string

Otra forma de no preocuparse por agregar una barra invertida antes de cada ' o " es usar ''' (comillas triples) en su lugar, y Python agregará la barra invertida donde sea necesario para nosotros:

1
2
3
>>> my_string = '''No need to worry about any ' or " we might have'''
>>> my_string
'No need to worry about any \' or " we might have'

Podemos demostrar la naturaleza "tipo débil" de Python al convertir un float en str:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
# Assigning float value to `z`
>>> z = 5.2

# Checking for the type of `z`
>>> type(z)
<class 'float'>

# Printing the value of `z`
>>> z
5.2

# Changing `z` into a string
>>> z = str(z)

# Checking the type of `z`
>>> type(z)
<class 'str'>

# Printing the value of `z`
>>> z
'5.2'

Podemos ver que z cambió su tipo sin mucho problema.

lista

A diferencia de las cadenas, las listas pueden contener secuencias ordenadas de cualquier tipo de datos, incluso varios tipos de datos diferentes dentro de la misma lista.

Se crean proporcionando los elementos de la lista entre [], p. [elemento1, elemento2] o simplemente escribiendo [] y agregando los elementos más tarde.

Hay métodos incorporados para invertir, clasificar, borrar, extender una lista, así como agregar (insertar al final), insertar o eliminar elementos en posiciones específicas, etc., entre otros métodos.

Se puede acceder a los elementos por su índice en la lista, con el índice comenzando en 0.

Para ver el primer elemento de la lista (si no está vacío) para una lista llamada alguna_lista, puede usar alguna_lista[0] y lo mismo se aplica a todos los demás elementos de la lista.

Estos elementos también se pueden cambiar en un índice i escribiendo some_list[i] = new_value.

Hagamos una lista y realicemos algunas operaciones en ella:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# Making an empty list
>>> some_list = []

# Printing the value of the list
>>> some_list
[]

# Checking the type of the list
>>> type(some_list)
<class 'list'>

# Appending an integer to the list
>>> some_list.append(5)

# Printing the value of the list
>>> some_list
[5]

# Inserting an element at the `0`th index
>>> some_list.insert(0, 'some string')

# Printing the value of the list
>>> some_list
['some string', 5]

# Printing the value of the element on the `1`st index
>>> some_list[1]
5

# Appending another element ot the list
>>> some_list.append(123)

# Printing the value of the list
>>> some_list
['some string', 5, 123]

# Assigning the second element, an already existing value, to a new value
>>> some_list[2] = 'a'

# Printing the value of the list
>>> some_list
['some string', 5, 'a']

Sin embargo, si intenta ordenar una lista con tipos que no coinciden:

1
2
3
4
>>> some_list.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'int' and 'str'

Dado que un int no se puede comparar con un str con el operador <, se genera un error. Aunque, si tuviéramos:

1
2
3
4
5
6
>>> some_list = [1, 6, 4, 2, 8, 7]
>>> some_list
[1, 6, 4, 2, 8, 7]
>>> some_list.sort()
>>> some_list
[1, 2, 4, 6, 7, 8]

Podríamos haberlo solucionado.

tupla

El tipo de datos tuple es muy similar a las listas, la única diferencia es que es inmutable y que se crea usando () en lugar de []. Esto significa que una vez que creas una tupla, no puedes cambiar los valores que contiene.

En la mayoría de los casos, son un poco más rápidos que las listas y se utilizan para proteger los datos para que no se modifiquen:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
# Creating a tuple
>>> some_tuple = ("some string", 5, True, float('nan'))

# Printing the value of a tuple
>>> some_tuple
('some string', 5, True, nan)

# Accessing an element of a tuple
>>> some_tuple[0]
'some string'

# Accessing elements from given index to the end of the tuple
>>> some_tuple[1:]
(5, True, nan)

# Accessing elements from given index to another given index
>>> some_tuple[1:3]
(5, True)

# Trying to assign a new value to the element at the `0`th index
>>> some_tuple[0] = 'some other string' # Causes an error

Tipo booleano - bool

El tipo de datos bool se utiliza para representar valores booleanos: Verdadero o Falso. El tipo de datos no puede contener ningún otro valor.

Sin embargo, Python volverá a convertir sin muchos problemas la mayoría de las cosas a bool. Es decir, si dice bool(5), Python lo considerará Verdadero, mientras que bool(0) se considerará Falso.

Básicamente, 0 es falso y 1 es verdadero. Cualquier cosa más allá de 1 también se trata como Verdadero. Algo similar ocurre con las cadenas en las que si asigna una cadena vacía, se trata como False.

Esta booleanificación (también llamada veracidad en Python) se realiza implícitamente en cualquier contexto en el que Python espera un valor bool. Por ejemplo, decir if(5) tiene el mismo efecto que if(bool(5)), es decir, if(True).

Veamos cómo podemos declarar y usar booleanos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
# Declaring a boolean
>>> some_bool = True

# Printing a boolean's value
>>> some_bool
True

# Checking a boolean's type
>>> type(some_bool)
<class 'bool'>

# Assigning an empty string to a boolean
>>> some_bool = bool('')

# Checking the boolean's value
>>> some_bool
False

Tenga en cuenta que Verdadero y Falso son palabras clave, y que no puede decir verdadero o falso:

1
2
>>> some_bool = false
# Throws an error

Tipo de diccionario - dict

A diferencia del grupo Sequence de tipos de datos, los dicts (diccionarios) son colecciones desordenadas. Específicamente, colecciones desordenadas de pares (clave, valor). Lo que significa que, a diferencia de las listas, por ejemplo, los valores están asociados con claves y no con índices enteros.

Un diccionario tiene la siguiente estructura:

1
2
3
4
5
6
{
    key1 : value1,
    key2 : value2,
    ....
    keyN : valueN
}

Es importante tener en cuenta que las claves tienen que ser únicas, mientras que los valores no. Cuando desee buscar un valor, pase su clave y recupere el par.

Los diccionarios se pueden crear agregando pares (clave, valor) entre {} (recuerde, [] es para listas y () es para tuplas), o simplemente escribiendo un {} vacío y agregando los pares más tarde.

Las claves y los valores pueden ser de diferentes tipos de datos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# Checking the value of a dict
>>> type({})
<class 'dict'>

# Assigning keys and values to a dict
>>> some_dict = { 5 : 'five', 4 : 'four'}

# Printing the value of a dict
>>> some_dict
{5: 'five', 4: 'four'}

# Accessing a dict element via its key
>>> some_dict[5]
'five'

# Assigning a new value to a key
>>> some_dict[6] = 'six'

# Printing the value of the dict
>>> some_dict
{5: 'five', 4: 'four', 6: 'six'}

# Removing the (key, value) pair that has the key 5 (this also returns the value)
>>> some_dict.pop(5) 
'five'

# Trying to access an element with the key 5
>>> some_dict[5] # Raises an error since the key 5 no longer exists

Conclusión

Python se escribió de tal manera que el código fuera lo más fácil posible de escribir, sin que el código fuera demasiado ambiguo.

Sin embargo, su naturaleza fácil de escribir y débilmente tipeada puede generar confusión cuando alguien más mira su código o cuando lo revisa un tiempo después de escribirlo. Es una buena práctica escribir qué tipo exacto se supone que es algo siempre que exista la posibilidad de ambigüedad y evitar reutilizar nombres de variables con diferentes tipos. s.

Licensed under CC BY-NC-SA 4.0