TUTORIAL 1

Lenguaje de programación: Python

Por: José Gerardo Carrillo González

Contenido:
Introducción a Python.............................................................................................................2
Instalación de Python..........................................................................................................2
Objetos....................................................................................................................................5
Tipo numérico.....................................................................................................................7
Secuencias.........................................................................................................................10
Clase str.........................................................................................................................10
Clase list.........................................................................................................................14
Métodos de la clase list.............................................................................................16
Copiar listas...............................................................................................................18
Clase tuple.....................................................................................................................20
Clase range.....................................................................................................................21
Tipo mapa..........................................................................................................................21
Diccionarios...................................................................................................................21
Tipo booleano....................................................................................................................22
Comprobar tipo de instancia.................................................................................................23
Conversiones.........................................................................................................................24
Conversión implícita.........................................................................................................24
Conversión explicita..........................................................................................................24
Operadores............................................................................................................................27
Operadores aritméticos......................................................................................................27
Operadores de comparación..............................................................................................29
Operador de asignación.....................................................................................................29
Operadores de asignación compuestos..........................................................................30
Operadores lógicos............................................................................................................30
Operadores de membresía y de identidad..........................................................................31
Operadores de membresía..............................................................................................31

1
 Operadores de identidad................................................................................................31
Diferencia entre operador is y operador ==..............................................................32
Sentencia de asignación........................................................................................................33
Expresión de asignación........................................................................................................35
Eliminación de objetos..........................................................................................................37
Comentarios en Python.........................................................................................................37
Referencias............................................................................................................................38

Introducción a Python

Python es un lenguaje de tipado dinámico (no es necesario declarar el tipo de una variable,
se determina el tipo de la variable cuando se hace la asignación, en tiempo de ejecución) y
es interpretado (no necesita ser complicado previo a ser ejecutado, es decir, el código se
ejecuta directamente línea por línea). Python es un lenguaje de alto nivel (usa un lenguaje
más natural para el ser humano lo que lo hace más fácil de usar) por lo que tiene tipos de
datos de alto nivel. En Python se puede implementar un programa en varios módulos, los
cuales pueden ser utilizados en otros programas de Python. Además, Python puede ser
usado como una calculadora.

Instalación de Python

La última versión de Python se puede encontrar en:

[Link]

Al descargar el ejecutable y correrlo, en la primera pantalla de la instalación se palomea la

opción “Add Python x.x to PATH” y se continua con la instalación. Al terminar la
instalación, dar clic en el botón de inicio (en Windows) y buscar IDLE (Python x.x yy-bit) .
La Figura 1 muestra como localizar el acceso directo desde Windows 10.

2
Figura 1. Icono IDLE en el menú inicio.

IDLE es la abreviación de Integrated Development and Learning Environment, la ventana

principal IDLE Shell x.x.x es un entorno grafico interactivo donde podemos ejecutar
instrucciones. De acuerdo con la Figura 1, al dar clic en el icono IDLE (Python x.x yy-bit),
aparece la pantalla de la Figura 2, en esta pantalla podemos escribir instrucciones de una
línea a la vez, o bien si damos clic en File, luego en New File, aparece una ventana nueva
donde se puede escribir un programa, guardarlo y ejecutarlo.

Figura 2. IDLE Shell.

Además, se puede acceder al intérprete de Python (el programa que ejecuta las
instrucciones) desde la terminal (Command Prompt) escribiendo python, para salir se hace
con quit() o con exit(). En el sistema operativo Windows si no pueden acceder al intérprete
de Python desde la terminal, se debe agregar el ejecutable de Python a PATH, para esto
vamos a Control Panel, a System, a Advanced system settings, a Environment Variables, a
3
User variables for user, y en Path agregamos la ruta donde se encuentra la aplicación
python y donde se encuentra la aplicación pip. Para corroborar que lo anterior quedo bien
en la terminal escribimos C:\Users\user>where Python, que en mi caso muestra

C:\Users\user\AppData\Local\Programs\Python\Python313\[Link]

Y escribimos C:\Users\user>where pip, que en mi caso muestra

C:\Users\user\AppData\Local\Programs\Python\Python313\Scripts\[Link]

Desde la terminal, si escribimos python -c COMANDO, sucede la instrucción descrita por

COMANDO; si escribimos python -m CODIGO, se ejecuta el código que tiene por nombre
CODIGO, la ruta del archivo de dicho código debe estar en la lista [Link], si no está la
debemos agregar, para esto en la ruta a site-packages (esta ruta puede variar) que podría ser

C:\\Users\\user\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages

crearemos el archivo [Link], que para el caso en que CODIGO (dar_clase.py)

este en la ruta 'C:\\Users\\user\\Desktop', el archivo debe contener las siguientes líneas:

import sys
[Link](['C:\\Users\\user\\Desktop',])

Por otro lado, si desde la terminal escribimos

python "C:\\Users\\user\\Desktop\\dar_clase.py"

se ejecuta dar_clase.py.

El intérprete está en modo interactivo cuando lee comandos desde una terminal (la interfaz
con la que el usuario interactúa con el ordenador). En la Figura 2 vemos que el intérprete
imprime un mensaje de bienvenida (donde se indica la versión de Python) y un aviso de
copyright, luego imprime el prompt primario, que son tres signos mayo que, es decir, >>>.
El prompt primario es el carácter o conjunto de caracteres que se muestran en la línea de
comandos para indicar que el intérprete está en espera de instrucciones; el prompt
secundario, que son tres puntos (…), aparecen al principio de cada línea cuando se ingresa
una construcción multilínea; para finalizar un comando multilínea, después del prompt
secundario dejamos la línea en blanco y presionamos enter. Las líneas que no comienzan
con prompt son emitidas por el intérprete, entonces si al inicio de una línea hay un prompt
es una entrada, si no lo hay, es una salida.
En la ventana IDLE Shell podemos escribir una línea a la vez, el intérprete de Python [1]
lee la instrucción y la convierte al lenguaje de la máquina para evaluarla. Ejemplo:

4
>>> 2+(2*3)
8

Notar que en la línea donde escribimos la instrucción en la parte izquierda tenemos el

prompt >>>, y en la línea donde se presenta el resultado a la izquierda tenemos espacios
vacíos. Es posible escribir en una línea una instrucción que requiere agrupar las
instrucciones de siguientes líneas en un bloque de instrucciones, este bloque debe de estar
intentando; en este caso aunque en IDLE Shell la indentación se pone automáticamente, en
el intérprete que invocamos desde Command Prompt no sucede así, la indentación la
tenemos que especificar nosotros (se deben dejar x espacios al principio de cada línea que
comprende el bloque, donde x debe ser mayor o igual que 1).

En el modo interactivo, la última expresión impresa (sin usar print) se asigna a la variable
_, ejemplo:

>>> 2+2
4
>>> _+8
12
>>> _/2
6.0

La variable _ debe ser tratada como de solo lectura, por lo que no la debemos usar para
asignarle explícitamente un valor (por ejemplo, _=0), de ser así crearíamos una variable que
anula la variable original y el comportamiento de referenciar la última expresión impresa se
perdería.
Las funciones del sistema (built-in functions, en inglés) son las que ya están definidas y
disponibles para el usuario. Por ejemplo, para redondear un número se tiene la función
round(x,y), donde x se redondea hasta y posiciones; para redondear un número decimal
hasta dos posiciones después del punto decimal escribimos:

>>> round(12.1234,2)
12.12

Objetos

Python es un lenguaje de programación orientado a objetos. Los datos en un programa de

Python se representan como objetos (el código también es representado como un objeto).
Cada objeto tiene una identidad, un tipo y un valor. El tipo determina las operaciones que el
objeto soporta y los valores que puede tomar. El tipo y la identidad de un objeto no
cambian; el valor puede cambiar si se trata de un objeto mutable, por el contrario, una vez
creado un objeto inmutable su valor no puede cambiar.

5
Un objeto puede ser una instancia de una clase [2]. En la clase se definen variables
(atributos) y funciones, las funciones serán los métodos de las instancias creadas a partir de
la clase, de modo que una instancia (un objeto) es una encapsulación de atributos y métodos
[3], [4], [5].
En Python un objeto puede ser nombrado, el nombre (o identificador) apunta al objeto, por
lo que con el nombre se puede acceder al objeto. A un objeto se le asigna espacio en la
memoria cuando es definido, es decir, cuando por medio de una instrucción de asignación a
un nombre se le asigna un objeto, por lo que el nombre hará referencia al objeto que se le
asigno. Para nombrar un objeto de determinado tipo, una función, una clase o un módulo se
pueden usar letras, números, y guion bajo (de acuerdo con la convención snake case, entre
palabras se debe poner guion bajo, por ejemplo: resultado_total). Además, no se puede
empezar un nombre con un número. Python es case sensitive, es decir, distingue entre
minúsculas y mayúsculas, por lo que el nombre V1 es diferente del nombre v1, aunque
ambos nombres pueden apuntar al mismo objeto,

>>> V1='número'
>>> v1=V1
>>> id(V1)
2173121498688
>>> id(v1)
2173121498688

Para conocer las palabras reservadas en Python (las que no se pueden usar como el
identificador de un objeto) lo hacemos con la lista [Link],

>>> import keyword

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

Para conocer si un nombre es una palabra reservada (o no) lo hacemos con la función
[Link]('NOMBRE'), siendo NOMBRE el nombre que queremos probar; se
obtiene True si NOMBRE es una palabra reservada, False en caso contrario, ejemplo,

>>> [Link]('None')
True
>>> [Link]('list')
False

A pesar de que list es un tipo de dato incorporado (built-in type), no es una palabra clave
(keyword), lo mismo pasa con str, set, dict, int, float, etc, ver referencia [6]. Entonces no
debemos usar el nombre de una clase para referenciar un objeto (para evitar que dicho

6
nombre deje de hacer referencia a la clase), aunque es posible hacerlo. A un nombre le
podemos asignar un literal (que representa directamente un valor), p. ej. x=1 (ver referencia
[7]), una expresión (una combinación de valores y operadores que se reduce a un valor), p.
ej. x=2+2, el resultado de llamar una función, p. ej. x=round(3.1416,2), o una combinación
de las anteriores, p. ej. x=1+round(2.2,0). En Python una variable es el nombre [8] que se
usa para referenciar un objeto, por lo que la instrucción de asignación lo que hace es
vincular un nombre y un objeto. Un objeto es de cierto tipo, puede ser de tipo numérico
(int, float, complex), booleano (bool), secuencia de caracteres (str), secuencia de objetos
(list, tuple, range), mapa (dict), conjunto (set, frozenset), entre otros.
Desde Python 3 no hay diferencia entre tipo y clase [9], por lo que en este documento son
intercambiables. A continuación, los tipos de objetos.

Tipo numérico

Tenemos tres tipos numéricos. El tipo int, que se usa para representar enteros con signo. El
tipo float, que usa para representar números reales. El tipo complex, que se usa para
representar números complejos; un objeto de tipo complex tiene atributos, si x es el nombre
de un número complejo, entonces [Link] regresa el valor de la parte real y [Link] regresa el
valor de la parte imaginaria, cada cual de tipo float. Con sys.float_info.max se obtiene el
valor positivo máximo representable de tipo float, con sys.float_info.min se obtiene el valor
normalizado [10]-[11] positivo mínimo representable de tipo float. Escribir en IDLE Shell:

>>> import sys

>>> sys.float_info.max
1.7976931348623157e+308
>>> sys.float_info.min
2.2250738585072014e-308

El valor más negativo representable de tipo float sería:

>>> sys.float_info.max*(-1)
-1.7976931348623157e+308

El valor menos negativo representable de tipo 'float' sería:

>>> sys.float_info.min*(-1)
-2.2250738585072014e-308

La información anterior depende de la máquina que se esté usando. En Python, un número

con punto decimal o con signo de exponente (que puede ser el resultado de una expresión o
de llamar una función) es un objeto de clase float. Además, cuando un operador aritmético
binario (el símbolo que se usa para determinar el tipo de operación que se llevara a cabo
entre dos operandos) tiene operandos de diferente tipo, el operando con el tipo “estrecho”

7
(o restrictivo) se “ensancha” al tipo del otro, se tiene que tipo int es más estrecho que float,
y que este es más estrecho que complex, por lo que Python soporta aritmética mixta, es
decir, un operador puede tener operandos de diferente tipo.
Con int(valor), float(valor), y complex(valor_1,valor_2), siendo el valor que va entre
paréntesis numérico (o bien puede ser texto que represente contenido numérico), creamos
un objeto (una instancia) de la clase indicada a la izquierda de los paréntesis (consultar
referencia [12]) y que tendrá por valor el que se escribió dentro de los paréntesis. Entonces
para crear un objeto de la clase int, float o complex, es decir, instanciar una clase, se hace
con el nombre de la clase seguido de paréntesis y dentro de los paréntesis el/los valor(es)
(ya que complex puede tener parte real y parte imaginara); por ejemplo, complex(r,i)
regresa un número complejo (un objeto de clase complex), con parte real r y con parte
imaginaria i.
Python tiene incorporado el módulo math, el cual tiene funciones y constantes [13]. Para
acceder al contenido de un módulo (un objeto con código) primero se debe importar,
entonces, para poder usar las constantes y funciones del módulo math se logra con la
palabra import seguido del nombre del módulo,

>>> import math

La Tabla 1 presenta algunas funciones para trabajar con objetos de tipo numérico.

Tabla 1. Funciones para usarse con objetos de tipo numérico.

Función Descripción
|(x)| Para obtener el valor absoluto de x.
divmod ( x , y) Regresa una tupla con 2 resultados.
La tupla contiene: (x // y, x % y)
pow(x , y) Para obtener x elevado a la potencia y
round (x , n) Para redondear x a n dígitos. Si no se especifica n, entonces
n=0.
math . trunc(x ) Para obtener la parte entera truncada de x
math . floor ( x ) Para obtener el entero mayor ≤ x
math . ceil (x) Para obtener el entero menor ≥ x
math . degrees ( x ) Para convertir el ángulo x de radianes a grados
math . dist ( p 1, p 2 ) Regresa la distancia euclidiana (d) entre dos puntos. P. ej., en
un plano de dos dimensiones con p1=[x1,y1] y p2=[x2,y2]
siendo las coordenadas de los puntos, entonces
d= √ (x 2−x 1)2+( y 2− y 1)2
math . gcd ⁡(¿ enteros) Regresa el máximo común divisor de los argumentos
(*enteros), es decir, regresa el entero mayor que si al dividir
cualquier argumento dado entre este, el residuo es cero. Los
argumentos deben estar separados por una coma.
math . lcm(¿ enteros) Regresa el mínimo común múltiplo de los argumentos
(*enteros), es decir, regresa el entero positivo más pequeño
que puede ser dividido por cada argumento dando el residuo

8
 cero.
math . modf (x) Regresa una tupla con dos valores de tipo float, el primero es
la parte fraccionaria de x, el segundo es la parte entera de x.

Para convertir el número x de base y a un número entero en base 10 se hace con int('x',
base=y), ejemplos,

>>> int('101',base=2)
5
>>> int('a2f',base=16)
2607
>>> int('12',base=10)
12

Para conocer el número de dígitos que se necesita para representar un entero en base 2, se
hace de la siguiente manera,

>>> n=64
>>> n.bit_length()
7
>>> bin(n)
'0b1000000'

Al convertir un número del sistema decimal a binario por medio de la función bin(n), con n
siendo un entero, se tiene el siguiente resultado (en orden de izquierda a derecha) entre
comillas: aparece el signo menos si el número a convertir es negativo, un cero, la b
expresando binario, y el resultado de la conversión.

De acuerdo con la ecuación n=x/y, para conocer x y y dado n lo hacemos con

(n).as_integer_ratio(), que entrega como resultado (x, y), ejemplos,

>>> (4).as_integer_ratio()
(4, 1)

>>> (8.2).as_integer_ratio()
(2308094809027379, 281474976710656)

Ya que los números se guardan en binario la precisión es limitada, por lo que si vamos a
trabajar con decimales podemos usar el paquete decimal para tener resultados más precisos,

>>> 0.2+0.2+0.2-0.6
1.1102230246251565e-16
>>> import decimal
>>> [Link](0.2)+[Link](0.2)+[Link](0.2)-[Link](0.6)
Decimal('5.551115123130313080847263336E-17')
>>> 1.1102230246251565e-16>5.551115123130313080847263336E-17
True

9
Secuencias

Una secuencia es una estructura de datos que contiene elementos (objetos) guardados con
un orden; se puede acceder a cada objeto de una secuencia por medio de un índice que
representa la posición del objeto en la secuencia. En esta sección veremos los tipos str, list,
tuple y range.

Clase str

Una cadena es una secuencia de caracteres. Un objeto de clase str es una cadena que va
entre comillas simples ('), o comillas dobles ("). Ejemplo:

>>> x1='si'
>>> x2="no"

Se puede usar el operador * para repetir tantas veces una cadena como el número por el
cual se multiplica (el resultado se concatena). El operador + se usa para concatenar cadenas,
es decir, unir cadenas para formar una sola. Ejemplo:

>>> (2*'zo')+'brar'
'zozobrar'

Si dos cadenas están una seguida de la otra separadas únicamente por espacios vacíos (o
incluso sin separación) se hace una conversión implícita que entrega un literal (una sola
cadena). Ejemplo:

>>> 'espanta' 'pajaros'

'espantapajaros'

Se puede acceder individualmente, o dentro de un rango (slicing en inglés [14]), a los

caracteres de una cadena. El índice de las posiciones empieza en 0, el cual es la posición
del primer carácter de izquierda a derecha. Si tenemos:

>>> letras='abcde'

Para acceder al carácter que está en la posición=x, seguido del nombre del objeto
escribimos corchetes y dentro de estos el número de la posición, es decir, nombre[x]. Por
ejemplo, para acceder al carácter que está en la posición 0 del objeto al que hace referencia
el nombre letras,

10
>>> letras[0]
'a'

Para acceder al carácter que está en la posición 1,

>>> letras[1]
'b'

Podemos acceder a los caracteres dentro de un rango. Para obtener 'bcd',

>>> letras[1:4]
'bcd'

El rango que se escribió va de la posición 1 a la posición 4, podemos notar que el carácter

de la posición 1 se muestra, pero el de la posición 4 no. Con nombre[x:y] se accede a los
caracteres (del objeto al que hace referencia nombre) que van de la posición x a la posición
y-1, por lo que x se incluye y y se excluye. Si x no se especifica por defecto es igual a cero
(x=0), si y no se especifica por defecto es igual al índice de la última posición más uno, es
decir, y=len(nombre). La función len(objeto) regresa el número de elementos de objeto, si
objeto es de tipo str, entonces regresa el número de caracteres (un espacio en blanco cuenta)
que tiene.
Se puede acceder a todo lo que está a la izquierda o a la derecha de cierta posición. Por
ejemplo, para acceder a todo lo que está a la izquierda de la posición y=2 (sin incluir esta
posición) se hace de la siguiente manera:

>>> letras[:2]
'ab'

No fue necesario especificar x ya que por defecto x=0. Ejemplo, se puede acceder a todo lo
que está a la derecha de x=2 (incluyendo esta posición):

>>> letras[2:]
'cde'

No fue necesario especificar y, ya que por defecto y = índice de la última posición + 1, en

este ejemplo y = 4 + 1 = 5, que también es el número de caracteres del objeto 'abcde'. Si
sumamos las dos últimas instrucciones tenemos la cadena completa.

>>> letras[:2]+letras[2:]
'abcde'

Ejemplo:

11
>>> cadena='Python'

En la Figura 3 (tomada de [Link] tenemos las

posiciones de la cadena 'Python'.

Figura 3. Posiciones de la cadena 'Python'.

De acuerdo con la Figura 3, para obtener 'yth' lo podemos hacer con el rango [1:4], o con el
rango [-5:-2], entonces

>>> cadena [1:4]

'yth'

>>> cadena [-5:-2]

'yth'

Si a nombre se le asignó un objeto de tipo str, con la función len(nombre) se puede conocer
el número de caracteres (un espacio vacío cuenta por un carácter) del objeto al que hace
referencia nombre. Tenemos que cadena='Python' (nombre=objeto) tiene 6 caracteres, por
lo que

>>> len(cadena)
6

Algunos de los métodos que podemos usar con objetos de tipo str son:

[Link](sub, start, end)

Donde string es un objeto de tipo str y sub es una cadena. Regresa el índice de valor más
bajo donde se encuentra sub en string dentro del rango determinado por start y end, que son
argumentos opcionales,

>>> 'hola'.find('h')
0

[Link](*args)
[Link](**kwargs)

12
Un objeto str puede tener campos de reemplazo que van entre llaves. En las llaves puede ir
el índice (numérico) de un argumento posicional o el nombre de un argumento de palabra
clave. Si tenemos [Link](*args), *args es un número variable de argumentos
(posicionales) sin nombre, si tenemos [Link](**kwargs), **kwargs es un número
variable de argumentos con nombre. En el resultado tenemos que en las llaves (los campos
de reemplazo) va el valor del argumento correspondiente. Ejemplo con argumentos
posicionales

>>> "Hola {0}. Adiós {1}.".format('Juan', 'Pepe')

'Hola Juan. Adiós Pepe.'

Ejemplo con argumentos con nombre

>>> "Hola {nombre1}. Adiós {nombre2}.".format(nombre1='Juan', nombre2='Pepe')

'Hola Juan. Adiós Pepe.'

[Link](iterable)

string es el separador (una cadena) e iterable es una lista de cadenas. Regresa un objeto str
integrado por cada cadena en iterable separadas por string, el cual puede ser un espacio en
blanco, es decir ' '. Ejemplo:

>>> ' '.join(['1','2','3'])

'1 2 3'

Para que el intérprete no tome en cuenta una comilla como la forma de cerrar una cadena,
usamos el carácter \, ejemplo

>>> 'jose\'s home'

"jose's home"

Los caracteres precedidos por \ se interpreten como caracteres especiales, para evitarlo se
debe indicar que se usaran cadenas sin formato, esto se hace de la siguiente manera,

>>> print(r'C:\carpeta1\nombre')
C:\carpeta1\nombre

Ya que de no especificarse así, \n hace cambio de línea,

>>> print('C:\carpeta1\nombre')
C:\carpeta1
ombre

13
Clase list

Una lista es una colección ordenada de objetos separados por coma y entre corchetes,
aunque una lista puede tener un solo objeto o estar vacía. La clase de una lista es list, los
objetos que contiene una lista pueden ser objetos de un mismo tipo o de diferentes tipos.
Una lista es un objeto mutable, es decir, se le pueden hacer cambios (agregar objetos,
eliminar objetos, sustituir un objeto por otro). Para crear una lista con cinco objetos de clase
int y que tenga por nombre lista1 escribimos

>>> lista1=[1, 2, 3, 4, 5]

A una lista se le puede agregar el contenido de otra lista con el operador +, por lo que es
posible hacer concatenación de listas (unir dos o más listas en una sola). Si a lista1 le
agregamos el contenido de otra lista, el resultado se puede referenciar con un nombre
diferente (lista2), o con el nombre previamente utilizado (lista1).

>>> lista2=lista1 + [6, 7, 9]

>>> lista2
[1, 2, 3, 4, 5, 6, 7, 9]
>>> lista1=lista1 + [6, 7, 9]
>>> lista1
[1, 2, 3, 4, 5, 6, 7, 9]

En una lista se puede reemplazar el contenido de determinada posición, lo que no se puede

hacer con una cadena (un objeto de clase str no se puede modificar, es inmutable). De
acuerdo con el contenido actual de lista1, para cambiar el número 9 (que está en la posición
7, ya que se empieza a contar desde la posición 0 de izquierda a derecha) por el número 8,
lo hacemos de la siguiente manera

>>> lista1[7]=8
>>> lista1
[1, 2, 3, 4, 5, 6, 7, 8]

La sentencia del [15] se usa para eliminar objetos, por lo que se puede usar para eliminar
objetos de una lista o eliminar la lista en su totalidad. Para eliminar el ultimo objeto en
lista2, es decir el número 9, procedemos así

>>> del(lista2[7])
>>> lista2
[1, 2, 3, 4, 5, 6, 7]

Para eliminar el objeto lista2,

14
>>> del(lista2)

Eliminar un objeto significa que el nombre del objeto será removido del espacio de
nombres (local o global) en el que fue definido [16], además, si ningún otro nombre hace
referencia al objeto, este será eliminado de la memoria.
Para agregar un objeto a una lista de manera que se agregue al final, es decir, en la siguiente
posición con respecto a la última posición existente, lo podemos hacer con el método
append(). Para agregar a lista1 el número 9,

>>> [Link](9)
>>> lista1
[1, 2, 3, 4, 5, 6, 7, 8, 9]

El método pop() regresa el objeto en la última posición y dicho objeto es removido de la

lista. Ejemplo

>>> [Link]()
9
>>> lista1
[1, 2, 3, 4, 5, 6, 7, 8]

Creamos una lista con seis objetos de clase 'str'

>>> lista2=['a', 'b', 'c', 'd', 'e', 'f']

Si queremos cambiar algunas de estas letras por la mayúscula correspondiente, lo podemos

hacer dentro de un rango. Si queremos cambiar las letras 'b', 'c', 'd', y 'e' por las mayúsculas
correspondientes, lo hacemos así

>>> lista2[1:5]=['B', 'C', 'D', 'E']

>>> lista2
['a', 'B', 'C', 'D', 'E', 'f']

Los objetos que acabamos de modificar los podemos eliminar de lista2 de la siguiente
manera

>>> lista2[1:5]=[]
>>> lista2
['a', 'f']

Con lista[:] se selecciona todo el contenido de lista, entonces, podemos dejar una lista sin
contenido (vacía) de la siguiente manera

15
>>> lista2[:]=[]
>>> lista2
[]

Asignemos contenido nuevo a lista1 y lista2

>>> lista1=[1, 2, 3]
>>> lista2=['a', 'b', 'c', 'd1']

La función len(lista) se puede usar para obtener el número de objetos en una lista,

>>> len(lista1)
3
>>> len(lista2)
4

Podemos crear una lista que contenga las dos listas anteriores

>>> lista3=[lista1, lista2]

>>> lista3
[[1, 2, 3], ['a', 'b', 'c', 'd1']]

Entonces lista3 es una lista con dos objetos, los cuales a su vez son listas que contienen más
objetos, por lo que lista3 es una lista de listas. En lista3 en la posición 0 tenemos el
contenido de lista1, en la posición 1 tenemos el contenido de lista2. A su vez, lista1 y lista2
tienen sus propias posiciones, en un rango de 0 a 2 y de 0 a 3, respectivamente. Por medio
de lista3 si queremos acceder al número 2 de lista1, lo hacemos con lista3[0][1]; con
lista3[0] se hace referencia a [1, 2, 3], y con lista3[0][1] al 2, entonces

>>> lista3[0][1]
2

Por medio de lista3 si queremos acceder a la cadena 'd1' de lista2, tenemos que con lista3[1]
se hace referencia a ['a', 'b', 'c', 'd1'], y con lista3[1][3] se hace referencia a 'd1', entonces

>>> lista3[1][3]
'd1'

Métodos de la clase list

Los métodos más comunes de un objeto de tipo list son:

[Link](x)

16
Añade el valor x al final de lista. Para este y los siguientes ejemplos de este apartado, lista
se refiere a una lista cualquiera, x representa el valor de un objeto, e iterable representa un
objeto iterable, es decir, que se puede acceder a sus elementos de uno a la vez por lo que
puede ser iterado en un ciclo [17].

[Link](iterable)

Agrega al fina de lista los elementos en iterable.

[Link](i, x)

Inserta el elemento x antes del elemento en la posición i.

[Link](x)

Remueve el primer elemento de lista con valor igual a x, de no encontrarlo se genera la

excepción ValueError.

[Link](i)

Remueve el elemento en la posición i de lista y además regresa dicho elemento, si no se

especifica el índice, es decir, si escribimos [Link](), entonces remueve y regresa el
elemento en la última posición.

[Link]()

Remueve todos los elementos de lista.

[Link](x, inicio, fin)

Regresa el índice del primer elemento con valor igual a x, si no encuentra dicho elemento
entonces se obtiene ValueError. Los argumentos inicio y fin son opcionales y son para
limitar la búsqueda en un rango que empieza con índice=inicio y termina con índice=fin;
este rango en matemáticas equivale a [inicio, fin), es decir, se incluye inicio pero no se
incluye fin.

[Link](x)

Regresa el número de veces que x aparece en lista.

[Link](key=None, reverse=False)

Ordena los elementos en lista, ver referencia [18]. Los argumentos key y reverse son
opcionales y por default toman el valor None y False, respectivamente; si reverse=True,
ordena de mayor a menor, si reverse=False, ordena de menor a mayor. Opcionalmente,
para ordenar una lista podemos usar la función sorted(iterable, key=None, reverse=False),

17
esta no modifica el iterable sino que toma sus elementos, los ordena, y regresa una lista
ordenada.

[Link]()

Invierte el orden de los elementos de lista.

[Link]()

Regresa una copia superficial (shallow copy en inglés) de lista, es decir, la copia y lista no
son referencias, sin embargo, los elementos que contiene la copia son referencias a los
elementos que contiene lista, ver referencia [19].

Algunos de los métodos que modifican una lista, como insert, remove y sort, regresan
None, que es un tipo de dato.
Si vamos a crear una lista por medio de la clase list y pasamos como argumento un objeto
iterable, el objeto creado será de tipo list y su contenido será cada elemento del objeto
iterable. Ejemplo:

>>> list('hola')
['h', 'o', 'l', 'a']

Copiar listas

Si tenemos que lista1=[], y que lista2=lista1, tenemos que lista2 hace referencia al mismo
objeto que lista1, por lo que los cambios que se le hagan a lista1 se reflejan en lista2 y
viceversa [20]. Ejemplo:

>>>lista1=[]
>>>lista2=lista1
>>>[Link](1)
>>>lista2
[1]
>>>[Link](2)
>>>lista1
[1, 2]
>>>id(lista1)
2002751351232
>>>id(lista2)
2002751351232

La función incorporada id(nombre) regresa un número entero que corresponde a la

identidad del objeto que tiene por identificador nombre. Mientras exista un objeto tendrá
una identidad, será única, y no cambiará. Como se puede ver la identidad de lista1 es la
misma que la de lista2, por lo tanto, ambos nombres hacen referencia al mismo objeto.

18
Para hacer una copia profunda (deep copy) de una lista, de modo que la lista (el objeto
original) y la copia no sean referencias, y que además los elementos que contiene el objeto
original y los elementos que contiene la copia no sean referencias (ver [21] y [22]), lo
haremos con la función deepcopy(), para lo cual es necesario importar el módulo copy.
Ejemplo:

>>>import copy
>>>a=[[],[]]
>>>b=[Link](a)
>>> id(a)==id(b)
False
>>>b[0].append(1)
>>>b
[[1], []]
>>>a
[[], []]

Con b=a[:] se tiene que las listas a y b son diferentes objetos, pero los objetos que
contienen son referencias. Nota: a is b es equivalente a id(a)==id(b), que es para comparar
el valor de las identidades. Ejemplo

>>>a=[[],[]]
>>>b=a[:]
>>>a is b
False
>>>a[0] is b[0]
True
>>>a[1] is b[1]
True
>>>b[0].append(1)
>>>b
[[1], []]
>>>a
[[1], []]

Otra manera de copiar superficialmente una lista con el mismo efecto que produce b=a[:],
es b=list(a) y b=[Link]().

Por medio de rebanado (slicing en inglés) se puede obtener una lista (el objeto copia) a
partir de una lista (el objeto original) con diferente identidad, sin embargo, los objetos que
contiene la lista copia son referencias a los objetos que contiene la lista original, por lo que
la lista copia es una copia superficial de la lista original. Ejemplo

>>> lista1=[[0],[1],[2],[3],[4],[5]]
>>> lista2=lista1[3:]
>>> [Link]([6])
>>> lista1[3].append('x')
19
>>> lista1
[[0], [1], [2], [3, 'x'], [4], [5]]
>>> lista2
[[3, 'x'], [4], [5], [6]]

Clase tuple

Una tupla contiene objetos separados por coma y entre paréntesis, la clase de una tupla es
tuple. Un objeto de clase tuple es inmutable, es decir, no se le pueden hacer cambios
(agregar objetos, eliminar objetos, sustituir un objeto por otro). Para definir una tupla vacía
lo podemos hacer así

>>> tupla1=()
>>> type(tupla1)
<class 'tuple'>

Se puede definir una tupla sin paréntesis (objetos separamos por coma), sin embargo, si
solo tiene un objeto se debe poner coma después de este.

>>> tupla1=1,
>>> type(tupla1)
<class 'tuple'>

Cuando se usan paréntesis para definir una tupla con un solo elemento, también es
necesario poner coma después del único elemento que contiene.

>>> tupla1=(1,)
>>> type(tupla1)
<class 'tuple'>

La clase type(nombre) regresa un objeto de clase type; esta función la usaremos para
conocer la clase del objeto al que hace referencia nombre. Ejemplo:

>>> tupla1=('h','o','l','a')
>>> type(tupla1)
<class 'tuple'>

Para acceder a los elementos de una tupla se hace igual que con una lista. Ejemplo

>>> tupla2=('a','d','i','ó','s')
>>> tupla2[3]
'ó'

20
Clase range

El tipo range representa una secuencia inmutable de números y se puede usar para repetir
un bucle for un determinado número de veces. La clase de este tipo de objeto es range y
tiene la siguiente estructura

range(start, stop, step)

Se tiene que start es el valor inicial de la secuencia, si este valor no es especificado por
defecto es cero; stop es el último valor de la secuencia y es forzoso especificarlo, no se
incluye este valor sino hasta stop-1; step es el valor de los incrementos; cada valor del
rango se puede ir calculando con la formula r[i] = start + step*i, siendo i el índice de cada
valor (iniciando en 0 y hasta j), de modo que r[j] < stop, y r[j+1] >= stop.

Tipo mapa

Diccionarios

Un diccionario está integrado por pares. Los pares de un diccionario van entre llaves y se
separan entre si con una coma. Un par es la correspondencia entre el objeto clave y el
objeto valor, de modo que en un diccionario un par se escribe clave:valor. Para acceder a
un valor se hace por medio de la clave. La clave debe ser un tipo de dato inmutable (int,
float, str, bool), una clave debe estar presente una sola vez en un diccionario [23]. El valor
puede ser cualquier tipo de objeto. La clase de un diccionario es dict. Ejemplo:

>>> dict1={'nombre':'él','edad':33,'profesión':'no se sabe'}

>>> type(dict1)
<class 'dict'>

Para acceder al valor que corresponde con la clave 'edad', la clave se toma como el índice.

>>> dict1['edad']
33

Para agregar un par clave:valor a un diccionario usamos la clave como índice y le

asignamos un valor, es decir, diccionario[clave]=valor, si es una clave ya existente el valor
dado reemplazará al anterior. Como ejemplo vamos a crear un diccionario con base en otro
diccionario.

21
Salida:
{'nombre': 'él', 'edad': 33, 'profesión': 'no se sabe'}

Con dict2={} se creó un diccionario vacío. Con el método [Link]() se obtiene un

objeto de tipo dict_items que contiene los pares del diccionario, por lo que se puede acceder
a cada par, de a uno a la vez, con la sentencia for. Es posible borrar un par clave:valor con
del, ejemplo

>>> del dict1['edad']

>>> dict1
{'nombre': 'él', 'profesión': 'no se sabe'}

Además, list(diccionario) regresa una lista con las claves de diccionario. Ejemplo

>>> lista=list(dict2)
>>> lista
['nombre', 'edad', 'profesión']

Con los operadores de membresía in y not in podemos verificar si una clave se encuentra o
no se encuentra, respectivamente, en un diccionario. Ejemplo

>>> 'edad' in dict2

True
>>> 'teléfono' not in dict2
True

Tipo booleano

Un objeto booleano puede tener por valor verdadero (True) o Falso (False). Un objeto
booleano es de clase bool, esta clase es una subclase de la clase int, por lo que en la
mayoría de los contextos True se comporta como un 1 y False se comporta como un 0. El
resultado de evaluar una condición puede ser True o False. Ejemplos:

>>> 1>2
False
>>> -1<1
True

22
>>> 1==3
False
>>> 1!=1
False

Como parte de la sintaxis de la sentencia if se tiene que establecer una condición; en el

siguiente ejemplo se puede apreciar que si la condición (a!=b) regresa True se ejecuta el
bloque del if, si regresa False se ejecuta el bloque del else.

Salida:
True

Comprobar tipo de instancia

La función isinstance(nombre, clase) regresa True si nombre es una instancia de clase,

regresa False en caso contrario. Ejemplo:

>>> x=1.2
>>> isinstance(x,int)
False
>>> isinstance(x,float)
True

Tenemos que isinstance(x,int) lo que se hace es evaluar si x (que hace referencia a 1.2) es
una instancia de clase int, por lo que regresa False. En cambio, isinstance(x,float) regresa
True ya que x es una instancia de clase float.
Tenemos que bool es una subclase de int, por lo que True y False son instancias de int, ver
referencia [24].

>>> isinstance(True,int)
True
>>> isinstance(False,int)
True

23
Conversiones

Conversión implícita

Para evitar perdida de datos, en la conversión implícita Python automáticamente hace la

conversión del tipo de dato ‘inferior’ al tipo de dato ‘superior’. Ejemplo:

>>> a=10
>>> type(a)
<class 'int'>
>>> b=20.1
>>> type(b)
<class 'float'>
>>> c=a+b
>>> print(c)
30.1
>>> type(c)
<class 'float'>

Conversión explicita

De acuerdo con el ejemplo anterior, a es int y b es float. Es posible sumarlos de la siguiente

manera:

>>> c=float(a)+b
>>> print(c)
30.1
>>> type(c)
<class 'float'>

El resultado de la suma es float, se puede ver que explícitamente convertimos a clase float
el valor de a para hacer la suma. En este caso el usuario define a que tipo va a convertir un
valor, por lo que puede haber perdida de datos. Por ejemplo, podemos crear una instancia
de la clase int o float a partir del valor de un objeto de clase str si todos sus caracteres son
de tipo numérico, para crear un objeto de clase float a partir de una cadena en esta puede
haber un punto decimal y decimales. También podemos crear un objeto de clase str a partir
del valor de un objeto de clase int o float. Si tenemos que v1=10 y v2='30', sumarlos no es
posible porque no son del mismo tipo, el operador + no puede sumar operandos int y str,
ejemplo

>>> v1=10
>>> v2='30'
>>> v2=int(v2)
>>> type(v2)

24
 <class 'int'>

Ahora, el objeto al que hace referencia v2 es de clase int, por lo que es posible sumar v1 y
v2.

>>> v1+v2
40

Si queremos concatenar v1='somos' con v2=100, obtendremos un error ya que no se puede

concatenar str con int. Ejemplo

>>> v1='somos'
>>> v2=100
>>> v2=str(v2)
>>> type(v2)
<class 'str'>
>>> v1+' '+v2
'somos 100'

Para obtener 'somos 100' se agregó un espacio entre las cadenas v1 y v2. Con int(cadena,
base) podemos crear un objeto de clase int del sistema númerico decimal con el valor de
cadena (un str con caracteres numéricos), base es el número de dígitos del sistema
numérico del valor de cadena. Ejemplo:

>>> x='1000'
>>> y=int(x,2)
>>> print(y)
8

Tenemos que '1000' es una cadena str, sin embargo, sin las comillas puede ser un número
base 2, por lo que es correcto base=2. Si no se especifica base, por defecto es 10.

Con la función hex(entero) podemos crear un objeto de tipo str que represente un valor
hexadecimal a partir de entero (de clase int y de base 10). Con la función oct(entero)
podemos crear un objeto de tipo str que represente un valor octal a partir de entero.
Ejemplos

>>> x=10
>>> hex(x)
'0xa'

>>> x=8
>>> oct(x)
'0o10'

25
Con set(secuencia) se obtiene un conjunto (un objeto de clase set) no ordenado a partir de
los objetos en secuencia. El resultado no repite objetos. Ejemplos

>>> x='123123123'
>>> y=set(x)
>>> print(y)
{'2', '3', '1'}

>>> x=['a','b','b','c','c','c']
>>> y=set(x)
>>> print(y)
{'a', 'b', 'c'}

Podemos obtener una lista (clase list) o a una tupla (clase tuple) al pasar como argumento
un objeto iterable a las clases list y tuple, respectivamente. Ejemplos

>>> x='hola'
>>> y=list(x)
>>> print(y)
['h', 'o', 'l', 'a']

>>> x=[1,2,3]
>>> y=tuple(x)
>>> print(y)
(1, 2, 3)

Con la clase bool se puede evaluar un objeto para obtener True o False. Considerando
bool(objeto), para valores numéricos el 0 se evalúa como False y cualquier otro número
como True. Una cadena vacía (con 0 caracteres) da False, pero si contiene uno o más
caracteres da True. Una lista, tupla, conjunto, o diccionario vacío da False, de lo contrario
da True. Ejemplos

>>> bool(0)
False
>>> bool(-1)
True
>>> bool(5.5)
True
>>> bool(1+2j)
True
>>> bool([1,2,3])
True
>>> bool(())
False
>>> bool('')

26
 False
>>> bool('0')
True
>>> bool(' ')
True

Notar que '0' no es de tipo numérico, sino una cadena con un carácter numérico. Además, ' '
es una cadena de clase str de longitud 1 (un espacio en blanco hace que la cadena no este
vacía).

>>> type(' ')

<class 'str'>
>>> len(' ')
1

Operadores
Python soporta los siguientes operadores (entre otros): aritméticos, de comparación, de
asignación, lógicos, de membresía, de identidad.

Operadores aritméticos

Un operador aritmético se usa para hacer operaciones con operandos de tipo numérico. En
la Tabla 2 se presentan por cada operador aritmético un ejemplo y una breve explicación.

Tabla 2. Operadores aritméticos.

Operador Ejempl Explicación
o
+ a+ b Suma de a y b
- a−b Diferencia de a y b
* a∗b Producto de a y b
/ a /b Cociente de a y b
// a /¿ b El cociente de a/b sin la parte decimal.
% a %b Residuo de a/b
** a**b a elevado a la b

Ejemplos:

>>> 9//2
4
>>> 9%2
1
>>> 10**2
100

27
Además, el resultado de una expresión se puede mantener sin cambio de signo con el
operador +¿ , o cambiar de signo con el operador −¿. Ejemplo

>>> +(1+1)
2
>>> -(1+1)
-2

Cuando se evalúa una expresión en Python se sigue la regla de precedencia, es decir, el

orden para llevar a cabo las operaciones. En la Tabla 3 se presenta la prioridad de los
operadores de mayor a menor [25], los operadores en un mismo cuadro tienen la misma
prioridad.

Tabla 3. Prioridad del operador.

Operador Significado
(expresiones...), [expresiones...], expresión entre paréntesis, visualización de lista,
{clave: valor...}, {expresiones...} visualización de diccionario, visualización de
conjunto
x[i], x[i:j], x(argumentos...), ‘subscription’ (para acceder a un elemento de x),
[Link] ‘slicing’ (para acceder a un rango de x), llamada a
función, acceder a un atributo
await x Expresión de esperar [26].
** Exponenciación
+, -, ~ Signo positivo, signo negativo, NOT a nivel de bits

*, @, /, //, % Multiplicación, multiplicación de matrices, división,

división de piso, residuo

+, - Adición, sustracción
<<, >> Desplazamiento a nivel de bits
& AND a nivel de bits
^ XOR a nivel de bits
| OR a nivel de bits
<, <=, >, >=, !=, ==, Comparaciones,
in, not in, is, is not operadores de membresía, operadores de identidad
not NOT lógico
and AND lógico
or OR lógico
if – else Expresión condicional
lambda Expresión lambda
:= Expresión de asignación

28
Cuando se tiene en una expresión operadores con la misma precedencia, se evalúan por
orden de izquierda a derecha. Ejemplo:

>>> 10%3*8/4
2.0

Lo que este dentro de paréntesis se evalúa primero. Ejemplo:

>>> 3*(10/5)/2
3.0

En Python, el operador ** tiene asociatividad de derecha a izquierda. Ejemplo:

>>> 2**1**2
2

Ya que, si la asociatividad fuera de izquierda a derecha el resultado sería 4, con paréntesis

podemos forzar que así sea.

>>> (2**1)**2
4

Operadores de comparación

La Tabla 4 muestra los operadores de comparación, como ejemplo se tiene que x=5 y que
y=10.

Tabla 4. Operadores de comparación.

Operador Ejempl Se lee Devuelve
o
¿=¿ x=¿ y x igual a y False
!= x!=y x diferente de y True
> x>y x mayor que y False
< x<y x menor que y True
>= x>=y x mayor o igual que y False
<= x<=y x menor o igual que y True

Operador de asignación

29
Para asociar un valor con una variable se usa el operador =, de modo que el nombre a la
izquierda del operador de asignación hará referencia al objeto (que tiene un valor y es de
determinado tipo) a la derecha del operador de asignación. Ejemplo:

>>> x=1

Tenemos que 1 es un objeto de tipo int, y su nombre (o identificador) es x. Cuando x se usa

en un módulo, el intérprete de Python buscará la dirección en memoria del objeto al que
hace referencia x, que es donde estará el 1. La identidad de un objeto es un número (de
clase int) único y constante mientras el objeto exista, además, es la dirección del objeto en
la memoria (si el intérprete es CPython). La identidad de un objeto se puede obtener con la
función incorporada id(nombre), ver referencia [27]. Ejemplo:

>>> id(x)
2011428784

Operadores de asignación compuestos

Tenemos que x=x+1 lo podemos simplificar como x+=1 por medio del operador de
asignación compuesto +=. Ejemplo:

>>> x=2
>>> x+=1
>>> x
3

La sintaxis x+=valor, aplica para los operadores: (+) (-) (*) (/) (%) (//) (**) (&) (|) (^) (>>)
(<<). La Tabla 5 presenta algunos ejemplos con x=10.

Tabla 5. Operadores de asignación compuestos.

Operador Ejemplo Resultado
+¿ x +¿ 5 x=15
−¿ x−¿ 5 x=5
¿=¿ x∗¿ 5 x=50
¿=¿ x /¿ 5 x=2
¿∗¿ x∗¿=2 x=100

El operador += no tiene el mismo efecto que =+. Con x=+1 se tiene que a x se le asigna
un +1, y con x=−1 se tiene que a x se le asigna un -1.

Operadores lógicos

30
Los operadores lógicos se usan para conectar expresiones, el resultado es un valor
booleano. Si a=True y b=False, se obtienen los resultados de la Tabla 6.

Tabla 6. Operadores lógicos.

Operador Ejempl Descripción Resultado
o
and a and b Si a y b verdadero, se obtiene verdadero, False
falso en caso contrario
or a or b Si a o b verdadero, se obtiene verdadero, True
Falso en caso contrario
not not a El opuesto de a False

Los operadores lógicos explicados por medio de diagramas de flujo en [28]. Si x=0,
not(x)=True. Con x como cualquier número racional diferente que cero, es decir
x ∈ Q∧ x ≠ 0, se tiene que not(x)=False.

Operadores de membresía y de identidad

Operadores de membresía

El operador in. Con la sentencia objeto in iterable, se obtiene True si objeto se encuentra en
iterable, False en caso contrario. Ejemplo

>>> lista1=[1,2,3,4,5]
>>> 1 in lista1
True
>>> 6 in lista1
False

El operador not in. Con la sentencia objeto not in iterable, se obtiene True si objeto no está
en iterable, False en caso contrario. Ejemplo

>>> lista1=[1,2,3,4,5]
>>> a=6; b=1
>>> a not in lista1
True
>>> b not in lista1
False

Operadores de identidad

31
El operador is. Con la sentencia objeto_1 is objeto_2, se obtiene True si la identidad de
objeto_1 es igual a la identidad de objeto_2 (lo que quiere decir que son el mismo objeto),
False en caso contrario. Ejemplo

>>> a=1000
>>> b=1000
>>> a==b
True
>>> a is b
False
>>> id(a)==id(b)
False
>>> c=a
>>> a is c
True
>>> id(a)==id(c)
True

De acuerdo con el ejemplo anterior, a pesar de que a y b tienen asignado el mismo valor, y
por lo tanto a==b da True (ya que el operador == compara valores), no son el mismo
objeto ya que su identidad no es igual. Sin embargo, la identidad de a y c es igual, por lo
que hacen referencia al mismo objeto.
El operador is not. Con la sentencia objeto_1 is not objeto_2, se obtiene True si la identidad
de objeto_1 no es igual a la identidad de objeto_2 (por lo que son objetos diferentes), False
en caso contrario. Ejemplo:

>>> a=10
>>> b=10.0
>>> a!=b
False
>>> a is not b
True
>>> id(a)!=id(b)
True

Como a!=b da False se tiene que los valores 10 y 10.0 no son diferentes, es decir, son
iguales. En Python, al comparar números de diferente tipo con los operadores de
comparación (ver Tabla 4) se tiene que se comparan los valores exactos de los números
comparados. Además, ya que a is not b da True, se tiene que la identidad de a es diferente
que la de b por lo que no hacen referencia al mismo objeto.

Diferencia entre operador is y operador ==

32
Cuando comparamos objetos con el operador is estamos comparando la identidad de los
objetos, que de ser la misma obtenemos True. La comparación a is b equivale a
id(a)==id(b), siendo a y b objetos cualquiera. Cuando usamos el operador == estamos
comparando valores, que de ser iguales obtenemos True. Cuando definimos un objeto en
Python, es decir, a una variable (nombre) le asignamos un objeto (por medio de un valor) se
crea un objeto nuevo con una identidad única, pero dependiendo de la versión de Python
hay excepciones [29]. Ejemplos con Python versión 3.10.6:

>>>a=1
>>>b=1
>>>a is b
True
>>>a==b
True
>>>a=1000
>>>b=1000
>>>a is b
False
>>>a==b
True
>>>a='123456789'
>>>b='123456789'
>>>a is b
True
>>>a==b
True
>>> a=[1,2,3]
>>> b=[1,2,3]
>>> a is b
False
>>> a==b
True

Entonces, si dos variables hacen referencia al mismo objeto, el valor de las variables es
igual; sin embargo, si el valor de dos variables es igual, no necesariamente hacen referencia
al mismo objeto.

Sentencia de asignación

Para definir un objeto se usa la sintaxis nombre = objeto, una vez definido el nombre a la
izquierda del operador hace referencia al objeto a la derecha del operador. Python tiene
referencia, es decir, un nombre apuntando a un objeto, pero no tiene puntero, es decir, un
nombre apuntando a un nombre. Ejemplo:

33
>>> a=1
>>> b=a
>>> a=2
>>> b
1

Aunque cambio el objeto al cual a hace referencia, b sigue haciendo referencia al objeto
que se le asigno cuando fue definido, por lo que b no hace referencia a a. Al escribir:

>>> h=1

Se define un objeto de clase int el cual es referenciado con h. Al escribir:

>>> del(h)

La eliminación de h implica que se remueve este nombre del espacio de nombres (local o
global, donde se haya definido) y que el objeto al que hace referencia h es eliminado de la
memoria si ningún otro nombre hace referencia a dicho objeto. Por lo que ahora h no está
definido,

>>> h
Traceback (most recent call last):
File "<pyshell#536>", line 1, in <module>
h
NameError: name 'h' is not defined

Si tenemos dos nombres referenciando el mismo objeto y usamos la función del(nombre)

para eliminar solo uno de ellos, el objeto no es eliminado de la memoria,

>>> h=10
>>> z=h
>>> id(h)
140725619647560
>>> del(h)
>>> id(z)
140725619647560

Tenemos la asignación de secuencia, en donde a una secuencia de nombres se le asigna una

secuencia de objetos, la asignación se hace en el orden como fueron escritos. Ejemplos

>>> a,b,c=1,2,3
>>> print(f'a={a}, b={b}, c={c}')
a=1, b=2, c=3

34
>>> a,b,c='123'
>>> print(f'a={a}, b={b}, c={c}')
a=1, b=2, c=3

En el ejemplo anterior la cadena ‘123’ tiene 3 caracteres, cada carácter se asigna a un

nombre en el orden presentado. Si ahora,

>>> a,*b=1,2,3,4,5,6
>>> a
1
>>> b
[2, 3, 4, 5, 6]

En este caso a hace referencia al primer objeto y b hace referencia a una lista con el resto
de los objetos, para lo cual fue necesario escribir *b. Si tenemos,

>>> a=b=c=3
>>> print(f'a={a}, b={b}, c={c}')
a=3,b=3,c=3

En el ejemplo anterior los nombres a, b y c hacen referencia al mismo objeto.

Expresión de asignación

La sintaxis de una expresión de asignación es (nombre := expresión), ver la referencia [30]

para conocer los casos en los que está prohibido usar expresión de asignación sin
paréntesis. Una expresión de asignación (o expresión nombrada) se usa para vincular un
nombre con el resultado de una expresión (un valor). En Python una expresión de
asignación puede aparecer en la mayoría de los contextos donde se puede escribir una
expresión arbitraria (definición de expresión y de sentencia en [31]); ya que una expresión
de asignación se reduce a un valor, esta puede ser parte de una expresión. El operador := en
ingles se conoce como operador walrus. El siguiente es un ejemplo en el que podría ser
conveniente usar una expresión de asignación.

Código 1.

Para escribir el código anterior en IDLE Shell ubicarse en File y dar clic en New file (o
Ctrl+N), en la ventana que aparece podemos escribir el código.

35
Explicación de Código 1. Se le presenta al usuario la siguiente cadena: 'Escriba sí o no: ',
luego se hace captura de texto que se asigna en la variable entrada. Posteriormente se entra
en un ciclo while que tiene por condición entrada != 'no', de acuerdo con la lógica de esta
condición si la cadena capturada es 'no', el ciclo termina, luego con la función print
imprimimos en pantalla 'Usted escribió: no', si la cadena capturada es 'sí' (o cualquier
cadena diferente que 'no') se procede con las instrucciones del bloque while. El bloque de
instrucciones del while comprende las líneas 5 y 6; la línea 5 es para imprimir en pantalla
'Usted probablemente escribió: sí' por medio de la función print; la línea 6 es para capturar
texto (asignado en la variable entrada) por medio de la función input, para lo cual se
muestra en pantalla 'Escriba sí o no: '. Dependiendo del valor de entrada, el while hace una
iteración o no.
Notar que tanto en la línea 1 como en la línea 6 vinculamos entrada con la cadena que
introduce el usuario. La variable entrada se define en línea 1, ya que de no estar definida no
puede usarse en la condición de la línea 3. En cada iteración del ciclo while a entrada se le
asigna un valor (línea 6). Mediante una expresión de asignación se puede simplificar
Código 1 como se muestra en Código 2.

Código 2.

En Código 2 en línea 1 donde escribimos la condición del ciclo while tenemos una
expresión de asignación:

(entrada := input('Escriba sí o no: '))

Una expresión de asignación se evalúa a un valor, el cual está determinado por la expresión
a la derecha del operador :=, este valor es vinculado con el identificador que está a la
izquierda del operador. En la línea 1 de Código 2 el valor que devuelve input('Escriba sí o
no: ') es vinculado con entrada por medio del operador :=, además, dicho valor se usa en la
condición (que es una expresión) del bucle while

(entrada := input('Escriba sí o no: ')) != 'no'

Códigos 1 y 2 (abreviados C1 y C2, respectivamente) hacen lo mismo. En C1 en línea 1 se

define entrada para posteriormente usar esta variable en la condición del ciclo while, si el
ciclo no fue finalizado, en línea 6 se vuelve a definir entrada ya que esta variable es
necesaria para finalizar el ciclo. En C2 en línea 1 tenemos una expresión (que involucra
una expresión de asignación) que se reduce a un valor que se utiliza para finalizar (o no) el
while. En C1 en líneas 1 y 6 tenemos una sentencia (o declaración) de asignación y en C2
en línea 1 tenemos una sentencia while y en su condición va una expresión de asignación.
Notar que una sentencia de asignación no se reduce a un valor, mientras que una expresión
de asignación sí lo hace.

36
Ejemplo. Definir a y b mediante sentencia de asignación para luego hacer una suma.

>>> a=1
>>> b=2
>>> c=a+b
>>> print(c)
3

Ejemplo. Definir a y b mediante expresión de asignación para hacer una suma.

>>> c=(a:=2)+(b:=3)
>>> print(f'a={a}, b={b}, c={c}')
a=2, b=3, c=5

Ejemplo. Definir b mediante expresión de asignación para hacer una suma.

>>> a=(b:=1+2+3)+4
>>> print(f'a={a}, b={b}')
a=10, b=6

Eliminación de objetos

Para eliminar objetos que previamente hemos definido podemos agregar en una lista los
nombres de los objetos que queremos eliminar, para luego eliminarlos en determinado
momento. Ejemplo, para eliminar a, b, y c:

a=1;b='dos';c=True
lista=['a','b','c']
for nombre in lista:
del(globals()[nombre])

La función globals() regresa un diccionario que contiene la información del ámbito global
del programa e incluye los objetos definidos por el usuario en dicho ámbito, que aparecen
como 'nombre': objeto. Entonces, del(globals()['nombre']) equivale a del(nombre), siendo
nombre el identificador del objeto que queremos eliminar.
Nota: Los objetos definidos dentro de una función o clase del ámbito global pertenecen a
un ámbito local.

Comentarios en Python
Lo que se escriba a la derecha del carácter numeral, es decir #, el intérprete de Python no lo
ejecuta, ya que es un comentario. Ejemplo:

37
>>> 2+(2*3) #Este es un comentario
8

Lo que escribamos dentro de un bloque que inicia con 3 comillas simples (o dobles) y
termina de igual manera, es un comentario. Ejemplo:

'''
Esto es
un comentario
'''
"""
Esto también es
un comentario
"""

Un comentario puede aparecer después de una instrucción o al inicio de una línea, pero no
dentro de una cadena de caracteres. Si escribimos el carácter numeral dentro de una cadena
(que va entre comillas), el intérprete lo toma como el carácter numeral y no como el
carácter para iniciar un comentario.

>>> cadena="#Esto no es un comentario, es una cadena"

Referencias

[1] Usemynotes. "What is Python Interpreter | How to run Python Shell?"

[Link] (accessed.
[2] Geeksforgeeks. "Python object." [Link]
(accessed.
[3] [Link]. "Instance Objects."
[Link]
%20function,%2C%20sort%2C%20and%20so%20on. (accessed.
[4] Geeksforgeeks. "Difference between Method and Function in Python."
[Link] (accessed.
[5] Tutorialspoint. "Are Python functions objects?"
[Link] (accessed.
[6] "Why isn't 'list' a reserved word in Python?"
[Link]
python#:~:text=list%20is%20not%20a%20keyword,you%20should%20be%20able
%20to. (accessed.

38
[7] stackoverflow. "Are numbers considered objects in python?"
[Link]
python (accessed.
[8] stackoverflow. "Why should I refer to "names" and "binding" in Python instead of
"variables" and "assignment"?"
[Link]
binding-in-python-instead-of-variables-and#:~:text=So%20the%20variable%20is
%20the,the%20variable%20is%20that%20object. (accessed.
[9] Stackoverflow. "Class vs. Type in Python."
[Link] (accessed.
[10] [Link]. "Normal vs Subnormal Floats."
[Link] (accessed.
[11] stackoverflow. "What is a subnormal floating point number?"
[Link]
number (accessed.
[12] stackoverflow. "Python: is 'int' a type or a function?"
[Link]
function#:~:text=int%20is%20a%20class.,you%20defined%20in%20the%20class
(accessed.
[13] w3schools. "Python math Module."
[Link] (accessed.
[14] M. Sánchez. "Slicing." [Link]
(accessed.
[15] w3schools. "Python del Keyword."
[Link] (accessed.
[16] [Link]. "The del statement."
[Link] (accessed.
[17] R. Soklaski. "Iterables."
[Link]
#:~:text=Definition%3A,over%20in%20a%20for%2Dloop. (accessed.
[18] [Link]. "Sorting HOW TO."
[Link] (accessed.
[19] [Link]. "copy — Shallow and deep copy operations."
[Link] (accessed.
[20] stackoverflow. "How do I clone a list so that it doesn't change unexpectedly after
assignment?" [Link]
so-that-it-doesnt-change-unexpectedly-after-assignment (accessed.
[21] stackoverflow. "What is the difference between shallow copy, deepcopy and normal
assignment operation?" [Link]
difference-between-shallow-copy-deepcopy-and-normal-assignment-oper (accessed.
[22] stackoverflow. "python list by value not by reference [duplicate]."
[Link]
(accessed.
[23] Realpython. "Restrictions on Dictionary Keys and Values."
[Link] (accessed.
[24] stackoverflow, "Comparing boolean and int using isinstance," ed.

39
[25] [Link]. "Operator precedence."
[Link]
(accessed.
[26] [Link]. "Corrutinas." [Link]
(accessed.
[27] [Link]. "Built-in Functions (id)."
[Link] (accessed.
[28] [Link]. "Python Logical Operators with Examples."
[Link]
improvement-needed/ (accessed.
[29] stackoverflow. "Two variables in Python have same id, but not lists or tuples."
[Link]
id-but-not-lists-or-tuples (accessed.
[30] [Link]. "PEP 572 – Assignment Expressions." [Link]
0572/ (accessed.
[31] stackoverflow. "What is an expression in Python?"
[Link]
(accessed.

40