Apéndice A — Variables y objetos.

Objetivo. Explicar los conceptos de variables y objetos, cómo es que se declaran y se usan mediante algunos ejemplos.

A.1 Reglas para definir los nombres de las variables.

En Python las variables:

son símbolos que permiten identificar la información que se almacena en la memoria de la computadora,
son nombres o etiquetas para los objetos que se crean en Python,
se crean con ayuda del operador de asignación =,
no se tiene que establecer explícitamente el tipo de dato de la variable, pues esto se realiza de manera dinámica (tipado dinámico).

Los nombres de las variables:

pueden contener letras, números y guiones bajos (_),
deben comenzar con una letra o un guion bajo,
se distingue entre mayúsculas y minúsculas, por ejemplo, variable y Variable serán nombres diferentes.
puede contener caracteres Unicode (véase Sección A.8 ).

A.2 Variables básicas.

Los siguientes ejemplos son definiciones de variables con nombres válidos:

El nombre de la variable con minúsculas, el valor es de tipo cadena (usamos comillas dobles para definir una cadena):

gabo = "Gabriel García Márquez"

El nombre de la variable contiene un número, el valor es de tipo entero:

gabo25 = 25

El nombre de la variable comienza con _, el valor es de tipo flotante:

_gabo = 3.1416

El nombre nombre de la variable contiene mayúsculas y minúsculas, el valor es de tipo número complejo: parte real + parte imaginaria (con j):

GaboComplejo = 3 + 2j

El nombre de la variable contiene un _, el valor es de tipo lógico

gabo_logico = True

Para imprimir el contenido de las variables antes definidas usamos la función print() como sigue:

print(gabo)
print(gabo25)
print(_gabo)
print(GaboComplejo)
print(gabo_logico)

Gabriel García Márquez
25
3.1416
(3+2j)
True

El tipo de cada variable se obtiene usando la función type():

type(gabo)

str

Observa que la variable gabo es de tipo str.

Python proporciona los siguientes tipos de variables básicas:

numéricos: int, float, complex,
cadenas: str y
lógicos: True y False.

En el Apéndice B se describen estos tipos básicos en detalle.

A.3 Funciones incorporadas (Built-in functions).

Las funciones print() y type(), empleadas en los ejemplos anteriores, son conocidas como Funciones incorporadas (Built-in functions) en Python, las cuales siempre están disponibles para usarse en cualquier código. La lista completa de estas funciones se puede consultar en https://docs.python.org/3/library/functions.html.

A lo largo de este texto se introducirán algunas de estas funciones con ejemplos sencillos. En este apéndice particularmente veremos el uso de las funciones: print(), type(), id(), chr(), ord(), del().

La función print() imprime el contenido de una variable y puede recibir varios argumentos a la vez, por ejemplo:

print(gabo, gabo25)

Gabriel García Márquez 25

Se puede imprimir el resultado de una operación:

print(3 * 4)

También imprime el resultado de otras funciones por ejemplo:

print(type(gabo))

<class 'str'>

En este caso se imprime el tipo de la variable gabo. Observa que se obtiene más información, particulamente nos dice que gabo es un objeto de la clase 'str'. Hablaremos un poco más de objetos y clases en la Sección A.5.

A.4 Variables con mayúsculas y minúsculas.

Python es sensitivo a mayúsculas y minúsculas en los nombres de las variables. En el ejemplo que sigue se definen tres variables distintas:

pi = 3.14     
PI = 31416e-4 
Pi = 3.141592

La variable pi hace referencia al número flotante \(3.14\).
La variable PI hace referencia al número flotante \(31416 \times 10^{-4}\) (se usa notación científica 31416e-4) que es equivalente a \(3.1416\).
La variable Pi hace referencia al número flotante \(3.141592\).

Estas tres variables son diferentes y se almacenan en lugares diferentes en la memoria de la computadora. La siguiente tabla muestra de manera esquemática los conceptos de nombre, valor e identificador en memoria de una variable:

Nombre		Valor	id en memoria
`pi`	\(\rightarrow\)	3.14	140425110809872
`PI`	\(\rightarrow\)	3.1416	140425110112240
`Pi`	\(\rightarrow\)	3.141592	140425110112016

El identificador en memoria de cada variable es un número entero, el cual puede cambiar en cada ejecución. La función id() permite conocer el identificador en la memoria de cada variable:

id(pi)

2124418474032

id(PI)

2124422132240

id(Pi)

2124422132368

Observa que cada variable tiene un número de identificador diferente.

Es posible imprimir el valor de la variable, su tipo y su identificador en una sola línea de código como sigue:

print(pi, type(pi), id(pi))
print(PI, type(PI), id(PI))
print(Pi, type(Pi), id(Pi))

3.14 <class 'float'> 2124418474032
3.1416 <class 'float'> 2124422132240
3.141592 <class 'float'> 2124422132368

A.5 Objetos y sus nombres.

Python es un lenguaje Orientado a Objetos.

Todo lo que definimos será un objeto de una clase determinada.
Una clase define atributos y métodos para los objetos.
Python tiene definidas clases de las cuales es posible construir objetos.

En los ejemplos anteriores, en donde se han definido algunas variables, lo que realmente está pasando es que se están creando objetos de diferente tipo (o clase) y se les da un nombre. Por ejemplo, la siguiente declaración:

a = 1

crea un objeto de tipo entero (<class 'int'>) cuyo nombre es a.

Si hacemos lo siguiente:

b = a

se crea otro nombre para el mismo objeto, NO se crea otro objeto.

Veamos lo anterior en la siguiente celda de código:

a = 1
b = a
print(a, type(a), id(a))
print(b, type(b), id(b))

1 <class 'int'> 140730842948520
1 <class 'int'> 140730842948520

Observa que las variables a y b tienen el mismo identificador, lo que significa que son dos nombres para el mismo valor 1.

Ahora observa el siguiente código y su resultado:

a = 1
b = a
print(a, id(a), type(a))
print(b, id(b), type(b))

b = 5.0
print(a, id(a), type(a))
print(b, id(b), type(b))

1 140730842948520 <class 'int'>
1 140730842948520 <class 'int'>
1 140730842948520 <class 'int'>
5.0 2124422131056 <class 'float'>

Nota que inicialmente a y b tienen el mismo identificador en memoria, por lo que son dos nombres para el mismo objeto que es de tipo entero.
Posteriormente, se crea el nuevo objeto, un flotante, y se le da el nombre b; en ese momento a y b hacen referencia a dos objetos diferentes y sucede que:
- el contenido de b es 5.0,
- b tiene un identificador diferente al de a
- y b ahora es de tipo flotante.

Esta conceptualización de objetos y sus nombres es muy importante cuando se manejan estructuras de datos más complejas.

Nota.

Usaremos el término variable para referirnos a los nombres de los objetos. Cuando sea conveniente usaremos el término objeto.

A.6 Definición de varios nombres a la vez.

La siguiente declaración genera tres nombres para el mismo valor 25.

x = y = z = 25

print(x, type(x), id(x))
print(y, type(y), id(y))
print(z, type(z), id(z))

Observa que se creó el objeto 25 de tipo <class 'int'> y los nombres x, y y z son nombres diferentes para el mismo objeto, lo cual se verifica observando que el identificador de cada variable es el mismo.

Hagamos ahora lo siguiente:

y = 2.7182

print(x, type(x), id(x))
print(y, type(y), id(y))
print(z, type(z), id(z))

25 <class 'int'> 140730842949288
2.7182 <class 'float'> 2124422132432
25 <class 'int'> 140730842949288

Observa que la variable y es de tipo flotante cuyo valor es 2.7182.

Podemos eliminar el nombre x con la función del():

del(x)

Ahora ya no es posible hacer referencia al objeto 25 usando el nombre x. Si intentamos imprimir x se generará un error indicando lo anterior:

print(x)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[46], line 1
----> 1 print(x)

NameError: name 'x' is not defined

Nota.

Observa que Python nos proporciona mucha información acerca del error. En este caso el error es de tipo NameError. Más información al respecto la puedes encontrar en el Apéndice Q.

Sin embargo, aún es posible hacer referencia al objeto 25 usando el nombre z:

print(z, type(z), id(z))

25 <class 'int'> 140730842949288

El objeto 25 será eliminado de la memoria cuando ya no exista un nombre que haga referencia a él. Entonces, si eliminamos z se elimina también el objeto 25 pues ya no habrá ningún nombre que haga referencia a él:

del(z)

Ahora si intentamos imprimir el contenido de la variable z obtendremos un error:

print(z, type(z), id(z))

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[49], line 2
      1 # Esto dará un error
----> 2 print(z, type(z), id(z))

NameError: name 'z' is not defined

A.7 Asignación múltiple.

Podemos hacer una asignación múltiple de objetos diferentes a variables diferentes, por ejemplo:

x, y, z = "una cadena", 3.141592, 50

print(x, type(x), id(x))
print(y, type(y), id(y))
print(z, type(z), id(z))

una cadena <class 'str'> 2085440089584
3.141592 <class 'float'> 2085414243824
50 <class 'int'> 140714900203976

Como se observa, las variables x, y y z hacen referencia a diferentes objetos de distinto tipo.

A.8 Caracteres Unicode

Unicode es un estándar para la codificación de caracteres, que permite el tratamiento informático, la transmisión y visualización de textos de muchos idiomas y disciplinas técnicas. Unicode intenta tener universalidad, uniformidad y unicidad.

Unicode define tres formas de codificación bajo el nombre UTF (Unicode Transformation Format): UTF8, UTF16, UTF32. Véase https://es.wikipedia.org/wiki/Unicode para más información.

En Python se utiliza la codificación unicode, podemos saber el tipo de codificación como sigue:

# Importamos el módulo sys
import sys

# Imprimimos el tipo de codificación
sys.stdout.encoding

'UTF-8'

Nota.

En la celda anterior estamos usando import. Esta declaración importa las bibliotecas que se requieran para realizar alguna tarea. En este caso se importa sys que contiene módulos, funciones y variables para acceder a información del sistema. Una explicación detallada de cómo funciona import la puedes encontrar en el Apéndice W.

La compatibilidad con UTF-8 en Python significa que se puede leer, escribir y manipular archivos de datos provenientes de fuentes diversas como archivos binarios, bases de datos, APIs web, entre muchas otras; estas fuentes pueden contener texto en diferentes idiomas y codificaciones.

A continuación se muestran algunos ejemplos de nombres de variables que contienen caracteres unicode:

# Acentos y caracteres de idiomas en el nombre de variables
México = "en el ombligo de la luna"
español = "lengua romance"
français = "langues romanes"
Ελληνικά = "Griego"
Русский = "Ruso"

# Símbolos matemáticos
𝜋 = 3.1416
ℏ = 6.626e-34

Estas variables se pueden usar como cualquier otra, por ejemplo podemos imprimir su contenido, determinar su tipo y su identificador en memoria, y las podemos usar en operaciones:

print(México, type(México), id(México))
print(𝜋, type(𝜋), id(𝜋))
print(2 * 𝜋)

en el ombligo de la luna <class 'str'> 2124429492432
3.1416 <class 'float'> 2124422130800
6.2832

También es posible imprimir el caracter unicode y su valor como sigue:

# Imprimimos el valor de la variable Ελληνικά
print("Ελληνικά = ", Ελληνικά)

Ελληνικά =  Griego

Los códigos Unicode de cada caracter se pueden dar en decimal o hexadecimal, por ejemplo para el símbolo \(\pi\) se tiene el código decimal 120587 y hexadecimal 0x1D70B. La función chr() convierte el código unicode en el caracter correspondiente:

# Código hexadecimal del caracter 𝜋
chr(0x1D70B)

'𝜋'

# Código decimal del caracter 𝜋
chr(120587)

'𝜋'

La función ord() obtiene el código Unicode de un caracter y lo regresa en decimal:

ord("𝜋")

También es posible obtener más información de los códigos unicode como sigue:

# Importamos el módulo unicodedata
import unicodedata 

print("       Símbolo:", "𝜋")
print("Código decimal:", ord("𝜋"))
print("     Categoría:", unicodedata.category("𝜋"))
print("Nombre oficial:", unicodedata.name("𝜋"))

       Símbolo: 𝜋
Código decimal: 120587
     Categoría: Ll
Nombre oficial: MATHEMATICAL ITALIC SMALL PI

Para más información véase: https://docs.python.org/3/howto/unicode.html

También en los siguientes dos enlaces se pueden obtener los códigos UTF8 de diferentes caracteres especiales:

A.9 Nombres inválidos para variables.

Los siguientes ejemplos NO SON VÁLIDOS para el nombre de variables. Al ejecutar las celdas se obtendrá un error en cada una de ellas.

1luis = 20      # No se puede iniciar con un número

  Cell In[60], line 1
    1luis = 20      # No se puede iniciar con un número
    ^
SyntaxError: invalid decimal literal

luis$ = 8.2323  # No puede contener caracteres especiales

  Cell In[61], line 1
    luis$ = 8.2323  # No puede contener caracteres especiales
        ^
SyntaxError: invalid syntax

for = 35        # Algunos nombres ya están reservados

  Cell In[62], line 1
    for = 35        # Algunos nombres ya están reservados
        ^
SyntaxError: invalid syntax

A.9.1 Palabras reservadas.

Como vimos en la celda anterior, no es posible usar las palabras reservadas de Python para nombrar variables. La lista de palabras reservadas se puede consultar con la siguiente expresión:

help("keywords")


Here is a list of the Python keywords.  Enter any keyword to get more help.

False               class               from                or
None                continue            global              pass
True                def                 if                  raise
and                 del                 import              return
as                  elif                in                  try
assert              else                is                  while
async               except              lambda              with
await               finally             nonlocal            yield
break               for                 not