Compendio Unidad 4

Tecnologías de la Información
FUNDAMENTOS DE PROGRAMACIÓN
4 créditos
Profesor Autor:
José Eduardo Párraga Valle, Mg.
Duglas Antonio Mendoza Briones, Mg.
Titulaciones Semestre
• Tecnologías de la Información en Línea Primero
PERÍODO OCTUBRE 2022 FEBRERO 2023

Índice
Tabla de contenido
Resultado de aprendizaje de la asignatura ...................................................................................................... 3

Unidad 4 Funciones, Colecciones y Archivos .................................................................................................. 3
1. COLECCIONES ........................................................................................................................................ 3
Listas .................................................................................................................................................................. 4
Crear una lista ................................................................................................................................................ 4
Acceder a un elemento ................................................................................................................................. 4
Obtener el índice ........................................................................................................................................... 5
Obtener cuantos elementos ......................................................................................................................... 5
Modificar un elemento................................................................................................................................... 6
Añadir un elemento ....................................................................................................................................... 6
Crear una lista vacía ..................................................................................................................................... 6
Insertar un elemento ..................................................................................................................................... 7
Concatenar dos listas.................................................................................................................................... 7
Extender una lista .......................................................................................................................................... 7
Eliminar elementos de una lista ................................................................................................................... 8
Ordenar una lista ......................................................................................................................................... 10
Comprobar la existencia ............................................................................................................................. 11
Recorrer una lista ........................................................................................................................................ 11
Función "range" ........................................................................................................................................... 12
Función "list"................................................................................................................................................. 13
Estadísticos básicos .................................................................................................................................... 13
Comprensión de listas ................................................................................................................................ 13
Acceder a parte de una lista ...................................................................................................................... 14
Copiar una lista ............................................................................................................................................ 15
Métodos de listas ......................................................................................................................................... 16
Tuplas .............................................................................................................................................................. 17
Función "tuple" ............................................................................................................................................. 17
Conjuntos ........................................................................................................................................................ 18
1
Función "set" ................................................................................................................................................ 18
Acceder a los elementos ............................................................................................................................ 18
Añadir elementos ......................................................................................................................................... 19
Eliminar elementos ...................................................................................................................................... 19
Estadísticos básicos .................................................................................................................................... 20
Operaciones de conjuntos.......................................................................................................................... 20
Métodos de conjuntos ................................................................................................................................. 22
Diccionarios.................................................................................................................................................... 23
Acceder a un elemento ............................................................................................................................... 24
Añadir un nuevo elemento ......................................................................................................................... 24
Cambiar un valor ......................................................................................................................................... 25
Eliminar elementos ...................................................................................................................................... 25
Recorrer un diccionario ............................................................................................................................... 26
Valores, claves y elementos ...................................................................................................................... 27
Anidar diccionarios ...................................................................................................................................... 28
Métodos de diccionarios ............................................................................................................................. 29
2. ¿Qué son las funciones? .................................................................................................................... 30
2.1. Paso de parámetros por valor ....................................................................................................... 31
2.2. Paso de parámetros por referencia ............................................................................................. 31
2.3. Ámbito de una variable ................................................................................................................... 32
3. Archivos .................................................................................................................................................. 33
3.1. ¿Qué es un archivo?........................................................................................................................ 34
3.2. Gestión de archivos de texto o plano ......................................................................................... 38
........................................................................................................................................................................... 40
2
Resultado de aprendizaje de la asignatura
Desarrollar y aplicar habilidades de programación mediante la abstracción de datos a

problemas planteados para proponer soluciones algorítmicas como una herramienta de
solución a problemas de sistematización informática.
Unidad 4 Funciones, Colecciones y Archivos
Resultado de aprendizaje de la unidad: Construir soluciones lógicas para simplificar la

programación mediante el uso de funciones y colecciones.
1. COLECCIONES
Una colección de datos en programación almacena 2 o más elementos en un arreglo con

distintos números de índex, por lo que nos ayuda a agrupar elementos que tengan algo que
ver unos con los otros. Existen cuatro tipos de colecciones de datos en el lenguaje Python:
List es una colección ordenada y modificable. Permite datos duplicados.
Tuple es una colección ordenada e inmutable. Permite datos duplicados.
Set es una colección que no posee un orden ni un índex. No existen datos duplicados.
Dictionary es una colección sin orden, modificable e indexada. No permite datos duplicados.
Al elegir un tipo de arreglo, es útil comprender las propiedades que cada uno posee. Elegir el
tipo adecuado para un conjunto de datos en particular podría significar la retención del
significado y aumentar la eficiencia o seguridad del programa.
3
Listas
Una lista es una colección ordenada de elementos del mismo tipo.
Crear una lista
En Python una lista se define entre corchetes ([]) separando los elementos por comas (,)
Como las listas suelen contener más de un elemento es una buena idea darlas un nombre en
plural.
1 frutas = ['platano', 'manzana', 'naranja', 'limon']

2 print(type(frutas))
3 print(frutas)
Resultado:
<class 'list'>
['platano', 'manzana', 'naranja', 'limon']
Acceder a un elemento
Dado que las listas están ordenadas podemos acceder a cada uno de sus elementos mediante
su índice. Este índice será 0 para el primer elemento e irá incrementandose progresivamente.
Podemos utilizar un elemento de una lista de la misma forma que utilizamos una variable.
Para acceder a un elemento escribiremos el nombre de la lista y, a continuación, el índice del
elemento al que deseamos acceder entre corchetes.
2 print(frutas[0])
3 print(frutas[1])
4 print(type(frutas[1]))
Resultado:
platano
manzana
<class 'str'>
4
Podemos acceder a los últimos elementos de una lista utilizando índices negativos de forma
que el último elemento será el -1, el anteúltimo el -2 y así consecutivamente.

2 print(frutas[-1])
3 print(frutas[-2])
Resultado:
limon
naranja
Obtener el índice
Es posible obtener el índice de la primera ocurrencia de un elemento en la lista con el

método index.
1 frutas = ['platano', 'coco', 'naranja', 'coco']

2 print(frutas.index('coco'))
Resultado:
Obtener cuantos elementos
Es posible contar cuantas veces aparece un elemento en la lista con el método count.
Para obtener el número total de elementos en la lista utilizaremos la función len.
1 frutas = ['platano', 'coco', 'naranja', 'coco']

2 print("Ocurrencias coco:", frutas.count('coco'))
3 print("Total elementos:", len(frutas))
Resultado:
Ocurrencias coco: 2
Total elementos: 4
5
Funciones vs Métodos
Cuando hablamos de un método de una colección, para invocarle utilizaremos el nombre de
la variable de la colección, un punto, y el nombre del método seguido de los argumentos
necesarios entre paréntesis (o ninguno si no es necesario). Un ejemplo es count.
Cuando hablamos de una función, para invocarla, utilizaremos el nombre de la función y como
argumento entre paréntesis irá el nombre de la variable de la colección. Un ejemplo es len
.
Modificar un elemento
Para modificar un elemento utilizaremos el operador de asignación = de la misma forma que
hacemos para modificar el valor de una variable.
2 frutas[0] = 'coco'
3 print(frutas)
Resultado:
['coco', 'manzana', 'naranja', 'limon']
Añadir un elemento
La forma más sencilla para añadir un elemento es con el método append que añade el nuevo
elemento al final de la lista.
1 frutas = ['platano', 'manzana']
2 frutas.append('coco')
3 print(frutas)
Resultado:
['platano', 'manzana', 'coco']
Crear una lista vacía

Podemos partir de una lista vacía y luego ir añadiendo elementos.
1 frutas = []
2 frutas.append('platano')
3 frutas.append('manzana')
4 frutas.append('coco')
5 print(frutas)
6
Resultado:
['platano', 'manzana', 'coco']
Insertar un elemento
Es posible insertar un elemento en una determinada posición mediante el método insert.

Pasaremos dos argumentos a este método: la posición que queremos para el nuevo elemento
y cual es su valor.
2 frutas.insert(1, 'coco')
3 print(frutas)
Resultado:
['platano', 'coco', 'manzana']
Concatenar dos listas
Con el operador + podemos concatenar dos listas.
1 f1 = ['platano', 'manzana']
2 f2 = ['coco', 'piña']
3 frutas = f1 + f2
4 print(frutas)
Resultado:
['platano', 'manzana', 'coco', 'piña']
Extender una lista
Podemos añadir a una lista el contenido de otra lista mediante el método extend o el
operador +=.

2 print(frutas)
3 frutas.extend(['coco', 'piña'])
4 print(frutas)
5 frutas += ['naranja', 'limon']
6 print(frutas)
7
Resultado:
['platano', 'manzana']
['platano', 'manzana', 'coco', 'piña']
['platano', 'manzana', 'coco', 'piña', 'naranja', 'limon']
Eliminar elementos de una lista
Es posible eliminar un elemento por su posición o por su valor.
Por posicion
Para eliminar un elemento por su posición utilizaremos la función del. Cuando

utilicemos del ya no será posible acceder al elemento borrado.
2 del frutas[0]
3 print(frutas)
Resultado:
['manzana', 'naranja', 'limon']
El método pop permite borrar el último elemento de la lista. Además, nos permite seguir
trabajando con él una vez borrado.

2 fruta_borrada = frutas.pop()
3 print(frutas)
4 print(fruta_borrada)
Resultado:
['platano', 'manzana', 'naranja']

limon
Podemos incluir un argumento en el método pop para indicar el índice del elemento que
deseamos borrar. También en este caso podemos seguir trabajando con el elemento.
8
2 fruta_borrada = frutas.pop(1)
3 print(frutas)
4 print(fruta_borrada)
Resultado:
['platano', 'naranja', 'limon']
manzana
Por valor
Si solo conocemos el valor del elemento que deseamos borrar, pero no su posición
podemos eliminarlo con el método remove.
2 frutas.remove('naranja')
3 print(frutas)
Resultado:
['platano', 'manzana', 'limon']
Remove elimina solo el primero
El método remove elimina solamente la primera ocurrencia del valor que especificamos.
Si existe la posibilidad de que aparezca varias veces será necesario crear un bucle que
se repita para borrar todos.
Eliminar todos los elementos

Con la función clear podemos eliminar todos los elementos de una lista.
2 frutas.clear()
3 print(frutas)
4 print(len(frutas))
Resultado:
[]
0
9
Ordenar una lista
Podemos ordenar los elementos de una lista con el método sort. Este método ordena la lista
de forma permanente.
2 frutas.sort()
3 print(frutas)
Resultado:
['limon', 'manzana', 'naranja', 'platano']
Orden descendente
Podemos ordenar la lista en orden inverso pasando al método sort el

argumento reverse=True.
2 frutas.sort(reverse=True)
3 print(frutas)
Resultado:
['platano', 'naranja', 'manzana', 'limon']
Orden temporal
Para ordenar una lista de forma solamente temporal podemos utilizar la función sorted. Esta
función también admite como argumento reverse=True.
2 print(frutas)
3 print(sorted(frutas))
4 print(frutas)
Resultado:
['limon', 'manzana', 'naranja', 'platano']
10
Invertir el orden
Podemos invertir el orden de los elementos de una lista con el método reverse. Para volver a
su estado original podemos invocar de nuevo el método reverse.
2 frutas.reverse()
3 print(frutas)
Resultado:
['limon', 'naranja', 'manzana', 'platano']
Comprobar la existencia
Podemos comprobar si existe un elemento en la lista con un if.

1 frutas = ['platano', 'manzana', 'naranja']
2 if 'manzana' in frutas:
3 print('manzana está en la lista')
4 if 'coco' in frutas:
5 print('coco esta en la lista')
Resultado:
manzana está en la lista
Recorrer una lista
Es posible recorrer los elementos de una lista para realizar operaciones sobre cada uno de
ellos. Para recorrer los elementos de una lista utilizaremos un bucle for.
2 for fruta in frutas:
3 print(fruta)
Resultado:
platano
manzana
naranja
11
Poniendo for fruta in frutas: logramos que las sentencias que vienen a continuación (están
desplazadas cuatro espacios a la derecha) se repitan para cada uno de los elementos de la
lista. En este caso solo hay una sentencia: print(fruta) que se repetirá para cada una de las
frutas. Podiamos enunciar este código como: "Para cada fruta en la lista de frutas, imprime el
nombre de la fruta".
fruta es el nombre de variable que utilizamos para poder acceder al elemento correspondiente
en cada repetición del bucle. Podemos utilizar el nombre que consideremos más conveniente.
Función "range"
La función range permite crear facilmente una serie de números.

1 for numero in range(1, 5):
2 print(numero)
Resultado:
1
2
3
4
La función range genera una serie de números comenzando con el primer número que
pasamos como argumento entre paréntesis y finaliza cuando alcanza el segundo número (sin
incluirle).
Si pasamos solamente un argumento, range lo considerará el valor de parada y comenzará la
secuencia en 0, así range(3) genera la serie [0, 1, 2].
Si pasamos un tercer argumento podemos especificar un salto entre los elementos.
1 for numero in range(1, 10, 3):
2 print(numero)
Resultado:
1
4
7
12
Función "list"
Podemos transformar otros objetos en listas con la función list. Es posible obtener, de esta
forma, una lista de números a partir de range.
1 rango = range(1, 5)
2 print(type(rango))
3 lista = list(rango)
4 print(type(lista))
5 print(lista)
Resultado:
<class 'range'>
<class 'list'>
[1, 2, 3, 4]
Estadísticos básicos
Las funciones min, max y sum nos ofrecen unos estadisticos básicos de una lista numérica.
1 numeros = list(range(0, 10))
2 print(min(numeros))
3 print(max(numeros))
4 print(sum(numeros))
Resultado:
0
9
45
Comprensión de listas
Podemos generar una lista a partir de un rango de forma manual partiendo de una lista vacia.
1 cubos = []
2 for numero in range(1, 5):
3 cubo = numero ** 3
4 cubos.append(cubo)
5 print(cubos)
Resultado:
13
[1, 8, 27, 64]
Una comprensión de lista o "list comprehension" en inglés nos permite generar una lista de
forma compacta y simple. Veamos el equivalente al ejemplo anterior utilizando compresión de
listas para crear nuestra lista.
1 cubos = [numero**3 for numero in range(1, 5)]
2 print(cubos)
Resultado:
[1, 8, 27, 64]
Acceder a parte de una lista
A un subconjunto de los elementos de una lista se le denomina "slice" en inglés que podemos
traducir por rebanada, trozo o corte. A la operación de obtener estas rebanadas se la denomina
"slicing" que denominaremos cortar una lista. El corte de una lista es, a su vez, otra lista.
Para obtener un corte de una lista debemos especificar el índice del primer y el último
elemento. Python no incluirá el último elemento especificado en el corte.
1 frutas = ['platano', 'manzana', 'naranja', 'limon', 'coco']
2 corte = frutas[1:3]
3 print(type(corte))
4 print(corte)
Resultado:
<class 'list'>
['manzana', 'naranja']
Si omitimos el primer índice, Python comienza por el primer elemento de la lista. Si omitimos
el segundo índice, Python cortará hasta el final de la lista.
2 print(frutas[:3])
3 print(frutas[1:])
Resultado:
['platano', 'manzana', 'naranja']
['manzana', 'naranja', 'limon', 'coco']
Podemos utilizar valores negativos de los índices para acceder a posiciones desde el final de
la lista. -1 sería el último elemento, -2 sería el anteúltimo elemento y así progresivamente. De
14
esta forma podemos acceder, por ejemplo, a los tres últimos elementos de una lista sin conocer
su tamaño:
2 print(frutas[-3:])
Resultado:
['naranja', 'limon', 'coco']
En el corte podemos especificar un tercer valor que indique el salto entre elementos.
2 print(frutas[1:4:2])
Resultado:
['manzana', 'limon']
Copiar una lista
Podemos realizar una copia de una lista (crear una lista nueva con los mismos elementos que
la original) realizando un corte que incluya a todos los elementos, es decir, que no especifique
ninguno de los índices.
2 copia_frutas = frutas[:]
3 copia_frutas.append('coco')
4 print("Original:", frutas)
5 print("Copia:", copia_frutas)
Resultado:
Original: ['platano', 'manzana', 'naranja']
Copia: ['platano', 'manzana', 'naranja', 'coco']
Otra opción para copiar una lista es utilizar el método copy.
2 copia_frutas = frutas.copy()
3 copia_frutas.append('coco')
4 print("Original:", frutas)
5 print("Copia:", copia_frutas)
Resultado:
Original: ['platano', 'manzana', 'naranja']
Copia: ['platano', 'manzana', 'naranja', 'coco']
15
Métodos de listas
Esta es la relación por orden alfabético de algunos de los métodos disponibles en un lista.
Método Descripción
append Añade un elemento al final de la lista
clear Elimina todos los elementos de la lista
copy Devuelve una copia de la lista
count Devuelve el número de elementos que contienen un

determinado valor
extend Añade los elementos de una lista (o de cualquier iterable)

al final de la lista
index Devuelve el índice del primer elemento con un

determinado valor
insert Añade un elemento en la posición especificada
pop Elimina un elemento en la posición especificada
remove Elimina un elemento con un determinado valor
reverse Invierte el orden de los elementos de una lista
sort Ordena los elementos de la lista
16
Tuplas
Una tupla Tuple es una lista inmutable, es decir, una lista que no puede cambiar a lo largo de
la ejecución de un programa. Por ello no podemos añadir ni eliminar elementos de una tupla
una vez creada.
Una tupla puede contener una mezcla de diferentes tipos de datos.
Una tupla se crea igual que una lista, pero en lugar de corchetes utilizaremos paréntesis.
1 posicion_tesoro = (37.0083, -3.6)
2 print("Latitud:", posicion_tesoro[0])
3 print("Longitud:", posicion_tesoro[1])
Resultado:
Latitud: 37.0083
Longitud: -3.6
Si bien no es posible cambiar uno de los valores de una tupla, si es posible asignar una nueva
tupla a la variable que la contiene, en el ejemplo anterior sería posible poner
posicion_tesoro = (27.745003, -82.759659).
Técnicamente una tupla se define por la presencia de las comas. Los paréntesis solo las hacen
más legibles. Así, si quisiéramos definir una tupla de un solo elemento pondríamos: t = (14,).
Función "tuple"
Con la función tuple podemos crear tuplas a partir de otras colecciones (objetos que
implementen el protocolo Iterable).
3 t = tuple(frutas)
4 print(t)
5 print(type(t))
Resultado:
<class 'list'>
('platano', 'manzana', 'naranja')
<class 'tuple'>
17
Conjuntos
Un conjunto o Set es una colección sin orden de objetos inmutables que no admite duplicados.
Un Setse define entre {}.
1 frutas = {'coco', 'platano', 'manzana', 'coco', 'naranja', 'coco'}
3 print(frutas)
Resultado:
<class 'set'>
{'manzana', 'coco', 'naranja', 'platano'}
El 'coco' solo se ha añadido una vez al Set. Dado que los elementos no tienen orden, no
podemos utilizar un índice entre corchetes para acceder a ellos.
Función "set"
Con la función set podemos crear conjuntos a partir de otras colecciones (objetos que
implementen el protocolo Iterable).
1 frutas = ('platano', 'manzana', 'naranja')
3 frutas_set = set(frutas)
4 print(type(frutas_set))
5 print(frutas_set)
Resultado:
<class 'tuple'>
<class 'set'>
{'platano', 'manzana', 'naranja'}
Acceder a los elementos
Es posible iterar sobre los elementos de un Set mediante un bucle for.

1 frutas = {'platano', 'manzana', 'naranja'}
2 for fruta in frutas:
3 print(fruta)
Resultado:
platano
18
naranja
manzana
Podemos comprobar si un elemento existe en la colección con la palabra clave in.

Devolverá True o False dependiendo de si existe o no.
2 print('platano' in frutas)
3 print('coco' in frutas)
4 print('coco' not in frutas)
Resultado:
True
False
True
Añadir elementos
Es posible añadir un nuevo elemento al Set con el método add. Con el

método update podemos añadir varios elementos al Set pasandole como argumento una
colección.
2 frutas.add('pera')
3 frutas.update(['coco', 'piña', 'platano'])
4 print(frutas)
Resultado:
{'pera', 'coco', 'manzana', 'piña', 'naranja', 'platano'}
Eliminar elementos
Para eliminar elementos utilizaremos los métodos remove y discard. Ambos eliminan el
elemento que les pasamos como argumento. La diferencia entre ambos métodos es
que remove lanza un error si el elemento no existe y discard no.
19
2 frutas.remove('platano')
3 #frutas.remove('coco') # Produciría un error
4 frutas.discard('coco') # No produce error
5 print(frutas)
Resultado:
{'manzana', 'naranja'}
Para borrar todos los elementos de la colección utilizaremos el método clear.
2 frutas.clear()
3 print(frutas)
Resultado:
set()
Estadísticos básicos
La función len nos devuelve el tamaño de un Set. Las funciones min, max y sum nos ofrecen
unos estadisticos básicos de una colección de números.
Si los valores son strings las funciones len, min y max nos devolverán el tamaño de la
colección y los string menor y mayor según el orden alfabetico.
1 numeros = {12, 8, 20, 20}
2 print(len(numeros))
3 print(min(numeros))
4 print(max(numeros))
5 print(sum(numeros))
Resultado:
3
8
20
40
Operaciones de conjuntos
Un conjunto Set admite las operaciones clásicas de teoría de conjuntos (unión, intersección,
diferencia y diferencia simétrica). Veamos un ejemplo:
20
1 s1 = {'platano', 'manzana', 'naranja'}
2 s2 = {'coco', 'piña', 'platano'}
3 print('s1:', s1)
4 print('s2:', s2)
5 print('Unión:', s1 | s2)
6 print('Intersección:', s1 & s2)
7 print('Diferencia:', s1 - s2)
8 print('Diferencia simétrica:', s1 ^ s2)
Resultado:
s1: {'platano', 'manzana', 'naranja'}

s2: {'coco', 'platano', 'piña'}
Unión: {'platano', 'piña', 'manzana', 'naranja', 'coco'}
Intersección: {'platano'}
Diferencia: {'manzana', 'naranja'}
Diferencia simétrica: {'manzana', 'coco', 'piña', 'naranja'}
Es posible utilizar la versión en método de los operadores. El código anterior sería equivalente
a escribir:
1 print('Unión:', s1.union(s2))
2 print('Intersección:', s1.intersection(s2))
3 print('Diferencia:', s1.difference(s2))
4 print('Diferencia simétrica:', s1.symmetric_difference(s2))
21
Métodos de conjuntos
Esta es la relación por orden alfabético de algunos de los métodos disponibles en un conjunto.
add Añade un elemento al conjunto
clear Elimina todos los elementos del conjunto
copy Devuelve una copia del conjunto
difference Devuelve un conjunto que contiene la diferencia entre

dos o más conjuntos
difference_update Elimina los elementos de un conjunto que están

incluidos en otro conjunto
discard Elimina el elemento especificado
intersection Devuelve un conjunto que es la intersección de otros

dos conjuntos
intersection_update Elimina los elementos de un conjunto que no están

incluidos en otros conjuntos
isdisjoint Devuelve cuando dos conjuntos tienen intersección o

no
issubset Devuelve cuando otro conjunto contiene el conjunto o

no
issuperset Devuelve cuando el conjunto contiene a otro conjunto

o no
pop Elimina un elemento del conjunto
22
remove Elimina el elemento especificado
symmetric_differenc Devuelve un conjunto con la diferencia simétrica de

e dos conjuntos
symmetric_differenc Inserta la diferencia simétrica de un conjunto en otro

e_update
union Devuelve un conjunto con la unión de conjuntos
update Actualiza un conjunto con la unión del conjunto con

otros
Diccionarios
Un diccionario (Dictionary) es un conjunto de asociaciones entre una clave y un valor.

Un diccionario se crea usando llaves { } y dentro de estas, separadas por comas,
parejas clave:valor.
1 ciudades = {'España': 'Madrid',
2 'Mexico': 'Guadalajara',
3 'Paraguay': 'Asuncion',
4 'Costa Rica': 'Cartago',
5 'Argentina': 'Mendoza'}
6 print(ciudades)
7 print(len(ciudades))
Resultado:
{'España': 'Madrid', 'Mexico': 'Guadalajara', 'Paraguay': 'Asuncion',
'Costa Rica': 'Cartago', 'Argentina': 'Mendoza'}
5
Con la función len podemos consultar cuantas entradas existen en nuestro diccionario.
23
Acceder a un elemento
Es posible acceder a los elementos escribiendo su clave entre corchetes. También se puede
utilizar el método get.
3 'Costa Rica': 'Cartago'}
4 print(ciudades['España'])
5 print(ciudades.get('Mexico'))
Resultado:
Madrid
Guadalajara
El método get admite un segundo argumento opcional que será devuelto si la clave buscada
no existe. Si existen posibilidades de que la clave buscada no exista es recomendable
utilizar get. Si no especificamos el segundo argumento en el get si la clave no existe devuelve
el valor None.
1 ciudades = {'España': 'Madrid', 'Mexico': 'Guadalajara', 'Costa Rica': 'Cartago'}
2 print(ciudades.get('Italia', 'El pais no está registrado'))
3 print(ciudades.get('Italia'))
Resultado:
El pais no está registrado
None
Añadir un nuevo elemento

Para añadir un nuevo elemento utilizaremos la clave entre corchetes y especificaremos cual
es su valor.
1 ciudades = {'España': 'Madrid', 'Costa Rica': 'Cartago'}
2 ciudades['Argentina'] = 'Mendoza'
3 print(ciudades)
Resultado:
{'España': 'Madrid', 'Costa Rica': 'Cartago', 'Argentina': 'Mendoza'}
24
Cambiar un valor
El valor asociado con cada clave se puede cambiar.

1 ciudades = {'España': 'Madrid', 'Costa Rica': 'Cartago'}
2 ciudades['España'] = 'Santander'
3 print(ciudades)
Resultado:
{'España': 'Santander', 'Costa Rica': 'Cartago'}
Eliminar elementos
Existen tres formas de eliminar elementos de un diccionario:
• Utilizando el método pop(<key>) eliminamos la entrada con la clave especificada
en key. Este método devuelve el valor de la clave que se desea eliminar. Si la clave
no existe un valor por defecto (si se ha asignado usando setdefault) es devuelto. Si
no se ha asignado, se generará un error.
• El método popitem() elimina el último item insertado en el diccionario. El método
devuelve la pareja key:value eliminada.
• La palabra clave del elimina la entrada con la clave especificada sin devolver nada.
Puede ser más eficiente que pop(<key>).
Veamos un ejemplo de cada uno de ellos:

2 print(ciudades)
3 ciudades.popitem() # Borra 'Costa Rica'
4 print(ciudades)
5 ciudades.pop('España')
6 print(ciudades)
7 del ciudades['Mexico']
8 print(ciudades)
Resultado:
{'España': 'Madrid', 'Mexico': 'Guadalajara', 'Costa Rica': 'Cartago'}

{'España': 'Madrid', 'Mexico': 'Guadalajara'}
25
{'Mexico': 'Guadalajara'}
{}
Con el método clear podemos eliminar todas las entradas del diccionario.

4 print(ciudades)
5 ciudades.clear()
6 print(ciudades)
Resultado:
{'España': 'Madrid', 'Mexico': 'Guadalajara', 'Costa Rica': 'Cartago'}

{}
Recorrer un diccionario
Podemos recorrer un diccionario con un ciclo for. El ciclo procesa cada una de las claves del
diccionario con las cuales podemos acceder a los valores. Veamos un ejemplo:

2 for pais in ciudades:
3 print(pais, end=', ')
4 print(ciudades[pais])
Resultado:
España, Madrid
Mexico, Guadalajara
Costa Rica, Cartago
El ejemplo anterior es equivalente a haber escrito for pais in ciudades.keys():. Si solo
especificamos el nombre del diccionario se itera por las claves, pero podemos iterar también
por los valores y por los pares (clave-valor).
26
Para poder iterar sobre los valores directamente utilizaremos el método values del diccionario.
4 for ciudad in ciudades.values():
5 print(ciudad)
Resultado:
Madrid
Guadalajara
Cartago
Es posible iterar por las entradas (clave-valor) simultaneamente con el método items.
2 for pais, ciudad in ciudades.items():
3 print(f"{pais}: {ciudad}")
Resultado:
España: Madrid
Mexico: Guadalajara
Costa Rica: Cartago
Podemos iterar por las claves o por los valores en orden utilizando una expresión como
for k in sorted(ciudades.keys()):
También podemos hacerlo evitando repeticiones si lo convertimos en un conjunto (Set)
previamente así for v in set(ciudades.values()):
Valores, claves y elementos
En un diccionario hay tres métodos que obtienen vistas diferentes de los datos que contiene:
• El método values devuelve una vista de los valores.
• El método keys devuelve una vista de las claves.
• El método items devuelve una vista de los elementos del diccionario (pares clave-
valor).
1 ciudades = {'España': 'Madrid', 'Mexico': 'Guadalajara'}
2 print(ciudades.values())
3 print(ciudades.keys())
4 print(ciudades.items())
27
Resultado:
dict_values(['Madrid', 'Guadalajara'])
dict_keys(['España', 'Mexico'])
dict_items([('España', 'Madrid'), ('Mexico', 'Guadalajara')])
Podemos comprobar si una clave pertenece al diccionario con la palabra clave in o not in.
1 ciudades = {'España': 'Madrid', 'Mexico': 'Guadalajara'}
2 print('Mexico' in ciudades)
3 print('Argentina' in ciudades)
4 print('Argentina' not in ciudades)
Resultado:
True
False
True
Anidar diccionarios
Las claves y los valores de un diccionario pueden ser cualquier objeto. Esto nos permite incluir
en los valores de un diccionario listas, tuplas, conjuntos o incluso otros diccionarios. Veamos
un ejemplo:
1 estaciones = {'Primavera': ('Marzo', 'Abril', 'Mayo'),

2 'Verano': ('Junio', 'Julio', 'Agosto'),
3 'Otoño': ('Septiembre', 'Octubre', 'Noviembre'),
4 'Invierno': ('Diciembre', 'Enero', 'Febrero')}
5 print(estaciones['Primavera'])
6 print(estaciones['Primavera'][1])
Resultado:
('Marzo', 'Abril', 'Mayo')

Abril
28
Métodos de diccionarios
Esta es la relación por orden alfabético de algunos de los métodos disponibles en un

diccionario.
clear Elimina todos los elementos del diccionario.
copy Devuelve una copia del diccionario.
fromkeys Devuelve un diccionario con las claves y valores

especificados.
get Devuelve el valor para la clave especificada.
items Devuelve una lista que contiene una tupla para cada
pareja clave-valor.
keys Devuelve una lista con las claves del diccionario.
pop Elimina el elemento con la clave especificada.
popitem Elimina la última entrada insertada.
setdefault Devuelve el valor de la clave especificada. Si la clave

no existe la crea.
update Actualiza el diccionario con los pares clave-valor

especificados.
values Devuelve una lista con todos los valores del

diccionario.
29
2. ¿Qué son las funciones?
Una función es como un programa pequeño que tiene un nombre para ser identificado y un
propósito funcional que cumple cuando se lo utiliza, éste pequeño programa (función) puede
formar parte de un programa mayor o de una librería, por ejemplo print(), len(), type(), sum(),
entre muchas otras, son algunas de las funciones que más se han utilizado en el desarrollo
del presente material bibliográfico, pero ahora usted aprenderá a crear sus propias funciones.
Es importante entender que las funciones al igual que las variables cumplen con la regla de
identificación única, es decir que en un programa o en una librería no está permitido que dos
funciones utilicen el mismo nombre, esto ya que al momento de ser utilizadas el intérprete no
sabría a quién utilizar en el proceso, el nombre de la función cumple las mismas reglas de
creación de nombres de variables, además obligatoriamente el nombre debe utilizar paréntesis
que permiten recibir datos del programa principal que la utiliza; una función utiliza la siguiente
sintaxis como regla para la creación de la misma:
Figura 1. Formato de la sintaxis para crear una función
Observe la celda [1] que la sintaxis comienza con el término def que significa la definición de
una función, seguido del nombre de la función. Entre paréntesis va la declaración de los
parámetros si lo hubiese. La función utiliza la función print() para imprimir un mensaje “Hola
Python”. Todo esto es en tiempo de desarrollo y en tiempo de ejecución de la función como
lo indica en la celda [2] realizamos el llamado del nombre de la función que devuelve un
mensaje.
30
2.1. Paso de parámetros por valor
La definición de la función uf_valor() es un ejemplo de paso por valor. La celda [1], la primera
línea es la creación de la función, como parámetros se declara numero, variable que recibe un
valor la función. La segunda línea tenemos una multiplicación por asignación a la variable
numero, la última línea utiliza la función print() para mostrar el cálculo de la variable numero.
La celda [2], la primera línea asigna a la variable n el valor de 10, la segunda línea ejecuta la
función enviando el valor de n.
Figura 2. Programa que muestra paso por valor.
2.2. Paso de parámetros por referencia
Este proceso es totalmente diferente al paso de parámetro por valor ya que no recibe una
copia de un valor aportado desde otra parte del programa, sino que recibe la dirección donde
se encuentra almacenado dicho valor, en otras palabras, toma posesión directa de dicho valor
pudiéndolo modificar a conveniencia, esta forma de tomar control de un valor exige lo
siguiente:
Las listas son objetos que en Python siempre van a pasar como referencia, al menos que se
pase una copia con slicing ejemplo: lista[:]. La función uf_paso_refe, declara una variable
numeros para recibir el objeto lista del exterior. Los elementos de la lista se recorren en un
bucle repetitivo for para modificar sus valores. Fuera de la función se declara una lista con el
nombre de lista asignando los elementos 2,4 y 6. En tiempo de ejecución le enviamos el objeto
31
lista a la función y después podríamos verificar la modificación de los valores iniciales. Esto es
un caso especifico de paso por referencia que observamos en la gráfica.
Figura 3. Ejemplo de función de paso de parámetros por referencia.
2.3. Ámbito de una variable
El concepto de ámbito de una variable define dos aspectos importantes, el primero permite el
reconocimiento de su existencia y el segundo especifica su tiempo de vida durante la ejecución
del programa; es importante recordar que en lenguaje Python todas las variables deben ser
declaradas antes de ser utilizada en cualquier proceso, esto más la ubicación donde se
produce la declaración definen su ámbito, así las variables pueden ser declaradas en tres sitios
diferentes:
Dentro de las funciones. - La existencia de la variable solo es reconocida dentro de la función

donde fue declarada, se las conoce como variables locales ya que estas variables solo son
reconocidas de forma local (dentro de la función) y no es reconocida en otras funciones o áreas
del programa, estas variables se crean al momento de ejecutar la función y son borradas al
momento de finalizar la función.
Fuera de todas las funciones. - La existencia de estas variables es reconocida dentro todas
las funciones, se las conoce como variables globales, todas las áreas del programa las pueden
utilizar, estas variables se crean al momento de ejecutar el programa y son borradas al
momento de finalizar el mismo.
Como parámetro de la función. - Su existencia es solo reconocida dentro de la función donde

es declarada, también se las conoce como variables locales, solo es reconocida de forma local
y no es reconocida en otras funciones o áreas del programa.
Para ilustra estas definiciones conceptuales analice el siguiente programa: Se necesita un

programa que permita enviar a una función un arreglo de números enteros, almacenar los
32
números pares e impares en una lista respectiva. La función devolverá el números mayor y
menor. Para esto último se creará variables dentro de la función.
Figura 4. Programa que ilustra el ámbito de una variable.
Observe que tanto la variable “Mayor” y “Menor”, son variables de ámbito local de la función.
La variable “mayor” y “menor”, son variable global donde recibimos el valor que devuelve
respectivamente la función. Se enfatiza que la función recibe un arreglo de números enteros,
los objetos de este tipo siempre pasan como referencia, por tal razón se crean afuera de la
función y no es necesario retornar las listas que se cargan con los números par e impar.
3. Archivos
Es importante destacar que todo proceso realizado por la computadora necesita ser
alimentado por datos o información pertinente que el usuario aporta al momento de ejecutar la
aplicación, considere que hasta ahora se ha tratado con información contenida en las variables
que ocupan espacio de almacenamiento en la memoria RAM, dicha información está activa al
momento que se ejecuta el programa pero esta desaparece al momento de finalizar el mismo,
considere que para cualquier usuario le resulta incómodo tener que registrar los mismos datos
cada vez que se ejecuta el programa, por lo que se propone crear y gestionar archivos físicos
33
desde las aplicaciones desarrolladas por el programador de forma que se pueda registrar y
almacenar tanto los datos ingresados como los resultados obtenidos.
Es importante entender que los computadores funcionan mediante el uso del sistema
operativo, esta plataforma controla al computador en su totalidad y por lo tanto posee sus
propias reglas de gestión en general, ante esta realidad, cada sistema operativo posee normas
de organización y gestión de la información que incluye la administración de los diferentes
medios de almacenamiento, este capítulo toma como modelo de aprendizaje el sistema de
almacenamiento utilizado por los sistemas operativos Windows, cabe indicar que, por la
estructura dada que ofrece el lenguaje de programación, se utilizará el sistema de organización
de archivos FAT ya que corresponde a la estructura propia del lenguaje en su contexto.
El objetivo de este apartado es conocer y gestionar la creación y apertura de archivos digitales,

haciendo uso de las herramientas que ofrece el lenguaje de programación, así como aplicar
las estructuras de datos como método organizativo de los registros digitales en la creación y
gestión de archivos de texto y binarios.
3.1. ¿Qué es un archivo?
Todo trabajo realizado y almacenado en un computador es considerado un archivo, estos se

almacenan en unidades de almacenamiento como discos duros, flash memory, CD, DVD,
entre otros, es decir las unidades de almacenamiento solo contienen archivos sin importar si
son videos, documentos, imágenes, programas, animaciones, publicaciones, presentaciones
o cualquier otro producto producido por el usuario mediante el uso del computador;
técnicamente un archivo es el resultado de registrar o almacenar la información organizada y
contenida internamente por el computador en variables, estos datos son gestionados mediante
la aplicación de instrucciones especializadas que permiten enviarlas y contenerlas en cualquier
unidad de almacenamiento, considere la siguiente gráfica que muestra los elementos que
intervienen en este proceso:
34
Figura 5. Secuencia de almacenamiento y recuperación de datos
(Demera, Pinargote, García, Rodríguez , & Loor , 2018)
Un archivo está compuesto por dos bloques de datos, el primer bloque y por lo general el
contenido más grande, es la información ingresada y procesada por el programa, estos datos
provienen de la memoria principal del computador, el segundo bloque es el más pequeño
básicamente son reconocidos como los atributos que identifican al archivo, en general los
archivos dependiendo del sistema operativo poseen entre otros los siguientes atributos:
nombre, identificador único, tipo de archivo, ubicación, tamaño, protección, fechas,
identificación de propietario, información de control, entre otros, considere que estos datos
variarán dependiendo del sistema operativo y en la forma en como se almacenan los mismos,
los archivos en general se los puede agrupar en dos tipos: archivos ASCII y archivos binarios.
Los archivos ASCII o también conocidos como archivos de texto o archivos planos, son
archivos cuyo contenido almacenado son caracteres ASCII, tal y cual como fueron ingresados
a la memoria principal del computador, su estructura está organizada en forma de documento
y no posee ningún formato especial, estos archivos al momento de ser leídos, su contenido se
reciben en secuencia y no de forma estructurada, es decir no respetan formatos ya que su
naturaleza es plana; los archivos binarios se diferencian de los archivos planos al momento de
ser leídos, ya que su estructura funcional y organizacional es respetada y por lo tanto se
organizan estructuralmente en memoria, es decir que en estos archivos se considera la
estructura original utilizada antes de ser almacenados sus datos, es por ello que son
ampliamente utilizados en formatos de música, videos, imágenes, animaciones, documentos,
presentaciones, entre otros. Los programadores necesitan conocer las actividades que se
pueden desarrollar tanto con los archivos planos como con los archivos binarios, en ambos se
puede realizar las siguientes actividades: solicitar operaciones con el archivo (crear y/o abrir),
liberar la operación solicitada (cerrado), leer el contenido de un archivo (lectura), escribir el
35
contenido a un archivo (agregar al final o sobre escritura total), cambiar el puntero en cualquier
operación, consultar los atributos de un archivo, manipular los atributos de cualquier archivo,
entre otras operaciones.
En la figura 5 se muestra los elementos lógicos y físicos que intervienen en el proceso de

lectura y almacenamiento de datos en los archivos, el flujo de información puede ser
bidireccional desde el programa que provee información para ser almacenada en las unidades
de almacenamiento como desde las unidades de almacenamiento hasta el programa que
necesita gestionar dicha información, sea cual sea el movimiento de la información el
programador se verá en la necesidad de aplicar los conocimientos tratados en los capítulos
anteriores referente a la administración de los diferentes tipos de variables y su gestión de la
memoria principal del computador; este proceso de enviar y obtener datos es similar en los
archivos físicos en cuanto a su organización y estructura, además se debe tener en cuenta la
existencia de la memoria temporal llamada BUFFER que es un recurso físico del computador
para contener de forma temporal la información de paso desde la memoria principal hasta las
unidades de almacenamiento, cada unidad de almacenamiento dependiendo del sistema
operativo posee su propia estructura organizacional de los archivos y por lo tanto sus propias
políticas de acceso a la información, para ejemplificar el funcionamiento de las unidades de
almacenamiento, se utilizará como modelo la estructura de un disco que servirán de base para
entender su organización y funcionamiento.
Un disco está compuesto por pistas, sectores y clúster, cada uno de ellos cumplen un propósito
específico; así las pistas son divisiones físicas en forma de filas concéntricas circulares, su
función permite la orientación de los mecanismos físicos y lógicos utilizados por la cabeza
lectora/escritora que permiten leer y guardar la información en el disco. Los sectores son las
divisiones que tiene una pista para almacenar la dirección y el contenido fragmentado de las
diferentes áreas que contienen la información del archivo, su organización es parecida a una
celda, esta puede almacenar aproximadamente 512 byte. Los clústeres son organizaciones
lógicas de sectores, es decir un clúster es la unión de varios sectores y su propósito radica en
organizar la información en grupos de sectores y así disminuir la administración de grandes
cantidades de direcciones por el uso de sectores independientes, observe la siguiente
ilustración gráfica que señala los diferentes elementos mencionados:
36
Figura 6. Elementos de Disco
Para ejemplificar el proceso de creación y almacenamiento de información de un archivo,

suponga que se ha creado y almacenado un documento cualquiera que contiene información
general sobre diferentes temas, asuma que el nombre de este archivo es “trabajo. txt”,
recuerde que todo archivo posee en su estructura la información que necesita el sistema
operativo para organizar y acceder a todo su contenido, en base a estos antecedentes observe
como el archivo quedaría almacenado de la siguiente forma:
Figura 7. Almacenamiento de archivos
37
Tenga en cuenta que los programas o aplicaciones en general cumplen con el propósito de
enviar los datos a la unidad de almacenamiento y también se encargan de recibirlos cuando
se necesite de la gestión de los mismos, básicamente el programa en realidad no sabe dónde
se almacenan dicha información, ya que para establecer el envío y la recepción de datos
almacenados, el programa debe apoyarse en el sistema operativo, que es quién establece las
reglas de gestión como donde almacenarlo, tipo de acceso (solo lectura o lectura y escritura,
etc), cantidad de espacio a utilizar, entre otras posibilidades de gestionar archivos físicos;
técnicamente el programa que desarrolla un programador solo podrá utilizar el nombre lógico
del archivo y un puntero que contiene la dirección física del mismo, estos datos son
proporcionados por el sistema operativo.
3.2. Gestión de archivos de texto o plano
Es importante entender que antes de que un programa pueda gestionar un archivo físico, el
sistema operativo debe recibir las instrucciones adecuadas para que el programa tenga acceso
a la dirección física del archivo; actualmente se maneja muchos datos a diario. Y estos datos
pueden provenir de múltiples fuentes, como bases de datos, desde Excel hasta archivos
planos, desde sitios web públicos como kaggle. No solo las fuentes, podría estar en cualquier
formato de archivo como .csv, .txt, .parquet, etc. Antes de comenzar a entender los datos,
necesitará saber las tres cosas básicas: cómo abrir, leer y escribir datos en archivos planos
para que luego pueda realizar análisis en ellos. Python ofrece las siguientes funciones para
crear y administrar los diferentes archivos:
open(): La función incorporada de Python open() tiene los siguientes argumentos: open (file,
mode = 'r', buffering = -1, encoding = None, errors = None, newline = None, closefd = True,
abridor = None) La función open () tiene casi 8 parámetros junto con sus valores
predeterminados para cada argumento, como se muestra arriba. Por ahora, se centrará en el
primer y segundo parámetro, que son esenciales para leer y escribir archivos. Entendamos el
primer argumento, es decir, archivo. file es un argumento obligatorio que debe proporcionar a
la función open, mientras que resto, todos los argumentos son opcionales y usan sus valores
predeterminados. En pocas palabras, el argumento del archivo representa la ruta donde reside
su archivo en su sistema. Si la ruta está en el directorio de trabajo actual, solo puede
proporcionar el nombre del archivo. De lo contrario, debe proporcionar la ruta absoluta del
archivo, como en los siguientes ejemplos:
mi_fichero=open('/content/drive/MyDrive/Colab Notebooks/Python/Fichero.txt')
38
Si el archivo reside en un directorio que no sea el directorio actual, debe proporcionar el valor
absoluto ruta con el nombre del archivo:
Modos de acceso
Los modos de acceso definen de qué manera desea abrir un archivo, si desea abrir un archivo
en:
• modo de solo lectura

• modo de solo escritura
• modo anexar
• ambos modos de lectura y escritura
Aunque existen muchos modos de acceso, como se muestra en la siguiente tabla, los más
utilizados son los modos de lectura y escritura. Especifica dónde desea comenzar a leer o
escribir en el archivo. Utiliza 'r', el modo predeterminado, para leer el archivo. En otros casos
en los que desee escribir o agregar, use 'w' o 'a', respectivamente.
¡Por supuesto, hay más modos de acceso! Eche un vistazo a la siguiente tabla:
39
Bibliografía
40
[1] G. Demera, M. Pinargote, R. García, M. Rodríguez y D. Loor , Desarrollo Práctico de la Programación,
Portoviejo: ©Ediciones UTM- Universidad Técnica de Manabí., 2018.
[2] M. A. P. Basurto y J. M. C. Espín, Introducción a la programación en C, Barcelona, Espana: Edicions UPC,

2000.
41

Compendio Unidad 4

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Compendio Unidad 4

Cargado por

Copyright:

Formatos disponibles

Tecnologías de la Información

• Tecnologías de la Información en Línea Primero

PERÍODO OCTUBRE 2022 FEBRERO 2023

Resultado de aprendizaje de la asignatura ...................................................................................................... 3

Desarrollar y aplicar habilidades de programación mediante la abstracción de datos a

Unidad 4 Funciones, Colecciones y Archivos

Resultado de aprendizaje de la unidad: Construir soluciones lógicas para simplificar la

Una colección de datos en programación almacena 2 o más elementos en un arreglo con

List es una colección ordenada y modificable. Permite datos duplicados.

Tuple es una colección ordenada e inmutable. Permite datos duplicados.

Una lista es una colección ordenada de elementos del mismo tipo.

Crear una lista

1 frutas = ['platano', 'manzana', 'naranja', 'limon']

1 frutas = ['platano', 'manzana', 'naranja', 'limon']

Es posible obtener el índice de la primera ocurrencia de un elemento en la lista con el

1 frutas = ['platano', 'coco', 'naranja', 'coco']

Obtener cuantos elementos

Para obtener el número total de elementos en la lista utilizaremos la función len.

1 frutas = ['platano', 'coco', 'naranja', 'coco']

Crear una lista vacía

Es posible insertar un elemento en una determinada posición mediante el método insert.

Extender una lista

1 frutas = ['platano', 'manzana']

Eliminar elementos de una lista

Es posible eliminar un elemento por su posición o por su valor.

Para eliminar un elemento por su posición utilizaremos la función del. Cuando

1 frutas = ['platano', 'manzana', 'naranja', 'limon']

['platano', 'manzana', 'naranja']

Eliminar todos los elementos

Podemos ordenar la lista en orden inverso pasando al método sort el

Podemos comprobar si existe un elemento en la lista con un if.

Recorrer una lista

La función range permite crear facilmente una serie de números.

Acceder a parte de una lista

append Añade un elemento al final de la lista

clear Elimina todos los elementos de la lista

copy Devuelve una copia de la lista

count Devuelve el número de elementos que contienen un

extend Añade los elementos de una lista (o de cualquier iterable)

index Devuelve el índice del primer elemento con un

insert Añade un elemento en la posición especificada

pop Elimina un elemento en la posición especificada

remove Elimina un elemento con un determinado valor

reverse Invierte el orden de los elementos de una lista

sort Ordena los elementos de la lista

Acceder a los elementos

Es posible iterar sobre los elementos de un Set mediante un bucle for.

Podemos comprobar si un elemento existe en la colección con la palabra clave in.

Es posible añadir un nuevo elemento al Set con el método add. Con el

s1: {'platano', 'manzana', 'naranja'}

add Añade un elemento al conjunto

clear Elimina todos los elementos del conjunto

copy Devuelve una copia del conjunto

difference Devuelve un conjunto que contiene la diferencia entre

difference_update Elimina los elementos de un conjunto que están

discard Elimina el elemento especificado

intersection Devuelve un conjunto que es la intersección de otros

intersection_update Elimina los elementos de un conjunto que no están

isdisjoint Devuelve cuando dos conjuntos tienen intersección o

issubset Devuelve cuando otro conjunto contiene el conjunto o

issuperset Devuelve cuando el conjunto contiene a otro conjunto

pop Elimina un elemento del conjunto

remove Elimina el elemento especificado

symmetric_differenc Devuelve un conjunto con la diferencia simétrica de