Skip to main content

Variables Primitivas

https://docs.python.org/3/tutorial/introduction.html

Siendo directo, vamos a abrir una consola python y comenzar a entender cómo Python entiende que algo es una string "texto" o si es un número.

Haz varias pruebas en la consola de Python para aprender.

Intencionalmente no creé ningún script Python para que no ejecutes el script y veas la salida, sino que ejecutes los comandos dentro de la consola y tengas intimidad con Python primero. Esta base de conocimiento debe fijarse con mucha práctica.

  • Todo lo que está entre comillas dobles o simples es un texto.

    • "Hola, soy un texto"

  • Como en matemáticas x + y = z, x es una variable al igual que en el lenguaje, y una variable puede ser cualquier cosa, desde un número con un valor, una string (que representa un "texto"), un booleano que representa True o False, o incluso una colección de elementos. Para definir una variable:

    • x = 5
    • y = 5.8
    • texto_prueba = "Hola, soy un texto"
    • j = True

  • Cuando hacemos referencia a una variable ya estamos tomando su valor, pero si queremos imprimir (mostrar) en la consola podemos usar la función print() pasando entre () lo que debemos imprimir.

    • >>> texto_prueba = "Hola, soy un texto"
      >>> print(texto_prueba)
      Hola, soy un texto
      >>>
      >>> print("7" + "4")
      74 <---- suma de strings, no hace el cálculo
      >>> print(7 + 4)
      >>> print("7" + 4)
      Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      TypeError: can only concatenate str (not "int") to str
      # Dio error porque está intentando sumar un string con un número
      >>> print(int("7") + 4)
      11 <---- la función int() transformó 7 string a 7 entero para hacer la suma
      >>> x = 5
      >>> y = 4
      >>> print (x + y)
      9
      >>>

Variables dinámicamente tipadas​

En Python, las variables son dinámicamente tipadas, lo que significa que no necesitas declarar explícitamente el tipo de una variable al definirla. Asignar un valor a una variable crea automáticamente la variable y determina su tipo según el valor asignado. Además, el tipo de una variable puede cambiarse durante la ejecución del programa, simplemente asignando un valor de un tipo diferente a ella.

¿Cuáles son los tipos de variables primitivas de Python?​

Toda la información que usaremos durante la programación se representa en la memoria del computador a través de un tipo de dato, también escucharás los términos clase o categoría para referirte a lo mismo.

Todos los objetos en Python están formados por estas 3 propiedades:

  • valor "1000010" o "B"
  • tipo o clase str, int, float, ...
  • posición en la memoria el número devuelto por la función id()

Entiende el concepto y enfócate en este momento en entender int, float, y string. Las variables de colecciones solo se usarán posteriormente. La idea de llegar con este conocimiento es abrir la mente sobre lo que una variable puede representar.

En Python no necesitamos declarar qué tipo de dato usar porque Python hace la inferencia de tipos dinámicamente, el intérprete primero verifica cómo se ve el valor y luego decide por sí mismo qué clase utilizar. Incluso puedes, si lo deseas, forzar el tipo de dato explícitamente, pero esto se considera redundante, no erróneo.

Números enteros (int)​

Esta parte de la explicación será más extensa, porque todo lo que esté aquí aplica para la mayoría de los otros tipos.

Representan valores enteros, como 1, 2, -3, etc.

>>> edad = 25
>>> type(edad)
<class 'int'>
>>> cantidad = int(3) # Fuerza el tipo, pero es redundante
>>> type(cantidad)
<class 'int'>

Podemos hacer una variedad de operaciones con este valor, estas operaciones forman parte de lo que llamamos Protocolo del objeto, y quien define los protocolos que el objeto implementa es la clase int. Si fuera otra clase, como veremos más adelante, serían otros protocolos.

Cada clase tiene diferentes protocolos, es decir, funciones que sirven para manipular su valor.

Para verificar todo lo que podemos hacer con un objeto del tipo int podemos hacer dir(<tipo>). Todo lo que está entre __ son los atributos especiales de la clase y lo que no tiene son atributos públicos.

>>> dir(int)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

La lista anterior muestra los nombres de todos los atributos de los objetos almacenados con la clase int, todo lo que comienza con __ y termina con __ lo llamamos métodos dunder y son atributos especiales del modelo de datos de Python, no necesitamos usar estos atributos directamente en nuestro código, sin embargo es importante saber cómo está implementado esto por Python porque a través de una lista de atributos serás capaz de determinar qué operaciones soporta ese objeto. Usaremos abstracciones que por debajo harán la llamada a estos métodos dunder. Por ejemplo, si encuentras __add__ significa que puedes sumar usando +.

>>> precio = 10
>>> impuesto = 2
>>> total = precio + impuesto
>>> total2 = precio.__add__(impuesto)
>>> print(total)
12
>>> print(total2)
12
>>>

En este momento no vamos a hablar de todos ellos porque son muchos y la idea es que poco a poco vayas entendiendo conforme uses, pero vamos a explorar un ejemplo simple y que probablemente usaremos siempre.

Números de punto flotante (float)​

Representan valores decimales, como 3.14, -0.5, etc. Si el número tiene su parte decimal, debe estar separada por un . será un float por inferencia.

>>> valor = 5/2
>>> type(valor)
<class 'float'>
>>> print(valor)
2.5

Carácter (chr)​

Para almacenar un carácter usamos chr. Una string es un conjunto de caracteres, por lo tanto la string "abc" está formada por los caracteres a b y c.

Existen varias tablas de caracteres usadas en computación pero en este entrenamiento nos quedaremos solo con dos ascii y utf8. Cada carácter tiene su código en la tabla ascii. No necesitas memorizar la tabla, visítala cuando la necesites.

ascii

Ya la tabla unicode - utf8 todos los caracteres de todos los idiomas incluyendo emojis.

chr(65) 'A' chr(66) 'B' chr(67) 'C' fruta = "🍉" fruta.encode("utf-8") b'\xf0\x9f\x8d\x89'

Booleanos (bool)​

Representan valores lógicos Verdadero (True) o Falso (False) siendo que la primera letra es mayúscula. Por defecto True vale 1 y False vale 0. Una suma sumará sus valores resultando en un nuevo valor, pero una operación and u or generará un resultado booleano.

  >>> x = True
  >>> y = False
  >>> x + y
  1
  >>> x and y
  False
  >>> x or y
  True
  >>> #--------------------
  >>> x = 1
  >>> y = 0
  >>> x and y
  0
  >>> x or y
  1
  >>>

NoneType​

Este es un tipo especial que sirve para cuando no poseemos un valor pero necesitamos que la variable esté definida porque en algún momento en el transcurso del programa reasignaremos esa variable.

>>> nombre = None
>>> print(nombre)
None
>>> type(nombre)
<class 'NoneType'>
>>>

Bytes (bytes)​

Representan secuencias inmutables de bytes, como datos binarios. Una variable del tipo bytes puede usarse para almacenar datos binarios, como archivos de imagen, archivos de audio, mensajes codificados, entre otros. Son útiles cuando necesitas manipular datos a nivel de bytes, en lugar de caracteres. Los bytes son elementos individuales de información que pueden representar caracteres, valores numéricos u otros datos binarios. Una variable del tipo bytes se define usando la notación b'', donde los bytes se especifican dentro de las comillas simples o dobles. La interpretación de los bytes depende de la codificación que se esté usando. Para convertir una secuencia de bytes en una string legible, es necesario decodificar los bytes usando una codificación apropiada, como UTF-8, ASCII, UTF-16, entre otras.

>>># Aquí tenemos datos en binario utf-8
>>> datos = b'\x48\x65\x6c\x6c\x6f'
>>> print(datos)
b'Hello' # Ve la notación
>>> print(datos[0])
72
>>> print(datos[1])
101
>>>># Voy a intentar imprimir algo más allá de la cadena de datos
>>> print(datos[100])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: index out of range # Fuera del rango
>>># Decodificando los bytes y guardando en la variable texto
>>> texto = datos.decode('utf-8')
>>> print(texto)
Hello
>>># Codificando a utf-16 y viendo qué pasa
>>> datos_nuevos = texto.encode('utf-16')
>>> print(datos_nuevos)
b'\xff\xfeH\x00e\x00l\x00l\x00o\x00'
>>> texto = datos_nuevos.decode('utf-16')
>>> print(texto)
Hello
>>># Codificando a utf-8 y viendo qué pasa
>>> datos_nuevos = texto.encode('utf-8')
>>> print(datos_nuevos)
b'Hello'
>>>
  • Generalmente trabajamos siempre con utf-8 en la mayoría de los casos.

Estos son tipos primitivos de Python, pero puedes crear los tuyos propios como veremos más adelante.

La base para iniciar el resto es entender exactamente cuáles son las variables de python. Sigue la documentación oficial y haz varias pruebas.

Por ejemplo, puedes hacer lo siguiente en Python:

>>> x = 10  # x es un entero
>>> print(type(x))
<class 'int'>
>>> x = "hello"  # x ahora es una string
>>> print(type(x))
<class 'str'>
>>> x = 3.14  # x ahora es un float
>>> print(type(x))
<class 'float'>
>>> x = True  # x ahora es un bool
>>> print(type(x))
<class 'bool'>

Esto es diferente de lenguajes estáticamente tipados, donde necesitas declarar explícitamente el tipo de una variable. Este tipo de enfoque puede requerir algunos cuidados.

>>> x: int = 3
>>> y = 3
>>> x + y
6
>>> x = True
>>> x + y
4 # Aunque x ahora es un bool donde true significa 1 aceptó la suma y yo había avisado que la variable x debería ser un entero.
>>> x = "un texto cualquiera"
>>> x + y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

Estos son los tipos de límites que necesitas conocer en un lenguaje. Ser un lenguaje que define variables como dinámicamente tipado da mayor poder al programador, tanto para resolver problemas como para hacer tonterías.

Strings, o cadena de caracteres (str)​

Hasta aquí hablamos de caracteres aislados como A, B, 🍉 pero al programar también necesitaremos juntar esos caracteres para formar palabras y frases, cuando creamos una variable del tipo texto en Python él a través de la presencia de comillas sean simples ' o dobles " almacena ese valor en una clase del tipo str y este tipo de dato puede almacenar uno o más caracteres.

>>> nombre = "David"
>>> type(nombre)
<class 'str'>

Y como ya debes haber imaginado aquí estamos almacenando cada una de las letras D, a, v, i, d con sus respectivos bytes y secuencia posicional en un único objeto. (la palabra string cadena o corriente).

La palabra "David" es una lista que contiene en cada posición un carácter de la tabla utf8.

>>> list(bytes(nombre, "utf-8"))
[68, 97, 118, 105, 100]
  • 68 es la D
  • 97 es la a
  • 118 es la v
  • 105 es la i
  • 100 es la d minúscula

Bien, para guardar el nombre "David" una vez más no necesitas preocuparte con todos estos detalles, basta hacer nombre = "David" y usar este texto para efectuar las operaciones que desees.

Ejercicios​

Primero intenta hacer solo buscando en la documentación oficial cómo hacer, si no puedes, ve a Examples/1-variaveis/ y mira el código.

Para empezar de la manera correcta, es necesario tener Pylint instalado en tu VSCode. Esto ayudará y forzará el uso de buenas prácticas.

Ejercicio 1 - Hello World​

  • Es buena práctica que todo script Python termine con una línea en blanco.
  • Es buena práctica que las variables literales (constantes) se declaren en mayúsculas (UPPER_CASE).
  • También es buena práctica que todo script Python explique su existencia.
  • Es buena práctica que los nombres de archivos no usen - sino _, ni números, por eso debe crearse hello_world.py y no hello-world.py

Crea un script, hello_world.py, con una variable llamada MSG conteniendo "¡Hola mundo!" e imprime el contenido de MSG.

¿Funcionaría sin las buenas prácticas? Sí... ¿Pero quieres aprender bien o no?

Y además del comentario de documentación, llamado DocString también es común la inclusión de variables de metadatos que comienzan y terminan con 2 guiones bajos __ la palabra que usamos para designar estas variables es Dunder, por lo tanto, Dunder version se refiere a __version__.

Ejercicio 2 - Inputs​

Crea un script, inputs.py, pregunta el nombre del usuario y muestra un mensaje de bienvenida.

Details

Pasa por el lint En el primer ejercicio la variable se define como UPPER_CASE (mayúscula) porque es una variable considerada de valor constante, es decir, final, que no sufrirá alteraciones. En este ejercicio la variable que recibirá el nombre de la persona debe ser lower case, es decir minúscula. ¿Funciona sin esto? Sí... ¿Pero quieres aprender bien verdad?

Ejercicio 3 - Formateando strings​

Copia el inputs.py del ejercicio anterior a format.py y haz que el nombre aparezca en medio de la string sin sumar varias strings agregando al final "¡Es un placer tenerte aquí!".

Details

Busca por f-string Tanto el format como el f-string resuelven nuestro problema. El lint ya muestra para hacer con f-string pero ambos códigos funcionan.

print(f"Bienvenido {nombre} ¡es un placer tenerte aquí!")
print("Bienvenido {} ¡es un placer tenerte aquí!".format(nombre))

Así sí algo como lo hecho abajo funcionaría, aunque no esté bien hecho:

nombre = "David"
edad = "37"
email = "[email protected]"
## ejemplo 1
print("El email de " + nombre + " de " + edad + " años es " +  email )
## ejemplo 2
print("El email de",nombre,"de",edad,"años es",email )

Sobre inputs​

Cuando leemos una variable digitada por el usuario usando input, si no forzamos que tenga un tipo, será considerada una string. Ejecuta el inputs_explain y mira el código.

Digite su nombre: David
Digite su edad: 37
nombre tiene el tipo <class 'str'>
edad tiene el tipo <class 'str'>

Ejercicio 4 - Inputs con enteros​

Basado en el código del inputs_explain crea el inputs_inteiro.py garantizando que la edad sea un entero, como en la salida abajo.

Digite su nombre: David
Digite su edad: 37
nombre tiene el tipo <class 'str'>
edad tiene el tipo <class 'int'> #<-----

Haz algunas pruebas digitando en edad cualquier cosa que no sea un número entero y mira el error.

Ejercicio 5 - Sumador Entero​

Crea el archivo inputs_int.py Lee dos entradas del tipo entero, suma los valores y guarda en otra variable e imprime un texto mostrando los valores de entrada y el resultado usando f-string en la función print() como hecho anteriormente en otros ejercicios Haz una prueba digitando valores no enteros y mira el error.

Objeto​

Todo en python es un objeto. Cuando una variable es del tipo string es un objeto de clase del tipo string.

Cuando forzamos un input a ser del tipo int es un objeto de clase del tipo int.

Cada clase tiene sus propios métodos de manipulación de valores. Con enteros podemos hacer cosas que no podemos hacer con strings y viceversa.

Un objeto contiene atributos y métodos que manipulan los valores de los atributos.

En el caso de una variable del tipo string, que es un objeto de clase string, tenemos el atributo que es el valor real de la string y varios métodos (funciones) que trabajan sobre ese valor.

Si comienzas un script python en el IDE siendo que el nombre del script ya tiene el .py al final, el IDE entenderá que ese ya es un archivo Python y te ayudará.

Al declarar X del tipo string, cuando presionamos el punto (.) aparecerán en el IDE varios posibles métodos que podemos usar con ese valor. Esta es una de las ventajas de tener un IDE preparado para trabajar con un lenguaje.

Podemos querer saber si los valores de esa string son numéricos, alfanuméricos, si está en mayúscula, minúscula, etc. Ve lo que un IDE nos trae.

metodos

Por ejemplo ¿esta string X que declaré puede transformarse en entero?

Ve el script python objetos_string con varias pruebas y ejecuta.

Ejercicio 6 - Objeto​

Usando un IDE para ayudarte, verifica los diferentes métodos que poseemos cuando declaramos una variable de otros tipos.