Lenguaje Python

Después de realizar la fase de análisis en donde se construye y se prueba un algoritmo,

se pasa a la fase de codificación, para lo cual se trabaja con un lenguaje de
programación.

Codificación
Consiste en llevar un algoritmo a un lenguaje de programación que permita la interacción
con el computador. Para llegar a éste objetivo una vez construido el algoritmo, se debe
pasar por las etapas de diseño, en donde se incluye la modularización, el diseño de
entradas y salidas y el diseño de operación del programa.

Para adelantar este proceso se va a utilizar el lenguaje Python, para lo cual se hace una
introducción de las características de este lenguaje.

Breve historia de lenguaje Python

Python. Se dice que es un lenguaje de más alto nivel en el sentido de que sus
instrucciones son más entendibles por un humano. Veamos cómo se escribiría el
programa «Hello, World»

print (‘Hello World’)

¿cómo entiende una máquina lo que tiene que hacer si le pasamos un programa
hecho en Python (o cualquier otro lenguaje de alto nivel)? La respuesta es un compilador
Los compiladores son programas que convierten un lenguaje «cualquiera» en código
máquina.
Se pueden ver como traductores, permitiendo a la máquina interpretar lo que queremos
hacer
Python es un intérprete en vez de un compilador, pero el efecto es prácticamente lo
mismo. La diferencia está en que el intérprete realiza la «compilación» (interpretación) y la
«ejecución» de una vez, mientras que el compilador genera un formato «ejecutable»
(código objeto) que se ejecuta en otra fase posterior

Hitos en la computación
Luego los avances en las ciencias informáticas han sido muy acelerados, se
reemplazaron los tubos de vacío por transistores en 1958 y en el mismo año, se
sustituyeron por circuitos integrados, y en 1961 se miniaturizaron en chips de silicio. En
1971 apareció el primer microprocesador de Intel; y en 1973 el primer sistema operativo
CP/M. El primer computador personal es comercializado por IBM en el año 1980.

Historia de los lenguajes más destacados

Creadores de los lenguajes de computación
El avance de la computación está íntimamente relacionado con el desarrollo de los
lenguajes de programación. Sus creadores y creadoras juegan un rol fundamental en la
historia tecnológica. Algunas de estos creadores son:
Python

Python es un lenguaje de programación de alto nivel creado a finales de los 80/principios

de los 90 por Guido van Rossum, holandés que trabajaba por aquella época en el Centro
para las Matemáticas y la Informática de los Países Bajos. Sus instrucciones están muy
cercanas al lenguaje natural en inglés y se hace hincapié en la legibilidad del código.
Toma su nombre de los Monty Python, grupo humorista de los 60 que gustaban mucho a
Guido.

Características del lenguaje

Python es un lenguaje de programación interpretado y multiplataforma cuya filosofía

hace hincapié en una sintaxis que favorezca un código legible.

. Libre y gratuito (OpenSource).

• Fácil de leer, parecido a pseudocódigo.
• Aprendizaje relativamente fácil y rápido: claro, intuitivo….
• Alto nivel.
• Alta Productividad: simple y rápido.
• Tiende a producir un buen código: orden, limpieza, elegancia, flexibilidad, …
• Multiplataforma. Portable.
• Multiparadigma: programación imperativa, orientada a objetos, funcional, …
• Interactivo, modular, dinámico.
• Librerías extensivas («pilas incluídas»).
• Gran cantidad de librerías de terceros.
• Extensible (C++, C, …) y «embebible».
• Gran comunidad, amplio soporte.
• Interpretado.
• Tipado dinámico5.
• Fuertemente tipado6.

Tipos de datos

Los programas están formados por código y datos. Pero a nivel interno de la memoria
del ordenador no son más que una secuencia de bits. La interpretación de estos bits
depende del lenguaje de programación, que almacena en la memoria no sólo el puro dato
sino distintos metadatos.
Cada «trozo» de memoria contiene realmente un objeto, de ahí que se diga que en
Python todo son objetos. Y cada objeto tiene, al menos, los siguientes campos:
• Un tipo del dato almacenado.
• Un identificador único para distinguirlo de otros objetos.
• Un valor consistente con su tipo.
Variables

Las variables son fundamentales ya que permiten definir nombres para los valores que
tenemos en memoria y que vamos a usar en nuestro programa.

Definición de variables

Nombre=valor

El valor determina el tipo de dato

Reglas para nombrar variables
En Python existen una serie de reglas para los nombres de variables:
1. Sólo pueden contener los siguientes caracteres2:
• Letras minúsculas.
• Letras mayúsculas.
• Dígitos.
• Guiones bajos (_).
2. Deben empezar con una letra o un guión bajo, nunca con un dígito.
3. No pueden ser una palabra reservada del lenguaje.

Palabras reservadas

Ejemplos de variables

Convenciones para nombres de variables.

Se recomienda que sean en inglés para que el código sea más universal

Los nombres van en minúsculas y con subrayado

Utilizar nombres autoexplicativos

Ejemplo
Para números de canciones

num_songs

Constantes

En el caso de las constantes utilizamos mayúsculas (incluyendo guiones bajos si es

necesario) para nombrarlas. Para la velocidad de la luz nuestra constante se podría
llamar: LIGHT_SPEED.

Ejemplos variables

Los nombres van a depender del contexto del problema que estemos tratando.
Como regla general:

• Usar nombres para variables (ejemplo article).

• Usar verbos para funciones (ejemplo get_article()).
• Usar adjetivos para booleanos (ejemplo available).

Asignación de variables

En Python se usa el símbolo = para asignar un valor a una variable:

Nombre= Expresión.

Algunos ejemplos de asignaciones a variables:

total_population = 157503
avg_temperature = 16.8
city_name = ‘San Cristóbal de La Laguna’

Algunos ejemplos de asignaciones a constantes:

SOUND_SPEED = 343.2
WATER_DENSITY = 997
EARTH_NAME = ‘La Tierra’

Python nos ofrece la posibilidad de hacer una asignación múltiple de la siguiente

manera:
tres = three = drei = 3

En este caso las tres variables utilizadas en el «lado izquierdo» tomarán el valor 3.

Conocer el valor de una variable

Hemos visto previamente cómo asignar un valor a una variable, pero aún no sabemos
cómo «comprobar» el valor que tiene dicha variable. Para ello podemos utilizar dos
estrategias:

1. Si estamos en una «shell» de Python, basta con que usemos el nombre de la variable:
>>> final_stock = 38934
>>> final_stock
38934

2. Si estamos escribiendo un programa desde el editor, podemos hacer uso de print:

final_stock = 38934
print(final_stock)

Conocer el tipo de una variable

Para poder descubrir el tipo de un literal o una variable, Python nos ofrece la función
type().
Veamos algunos ejemplos de su uso:

Con el Shell de python

>>> type(9)
<class ‘int’>
>>> type(1.2)
<class ‘float’>
>>> height = 3718
>>> type(height)
<class ‘int’>
>>> sound_speed = 343.2
>>> type(sound_speed)
<class ‘float’>

con editor

print(type(9))
<class ‘int’>

Print( type(1.2))
<class ‘float’>

height = 3718
print( type(height))

<class ‘int’>

sound_speed = 343.2
print(type(sound_speed))

Conocer la dirección de una variable

>>> a = 7
>>> id(a)
4310690288

Con editor

a=7
print (‘dirección -> ‘,id(a))
dirección -> 4310690288

Manejo de números

En Python el manejo de números se lo hace con los tipos

bool
int
float

bool corresponde al tipo de dato boolean que maneja dos valores

True (1)
False (0)

Ejemplos

>>> is_opened = True

>>> is_opened
True
>>> has_sugar = False
>>> has_sugar
False

Con editor

is_opened = True
print( is_opened)
True
has_sugar = False
print(has_sugar)
False

Tener cuidado con la primera letra de True y False, deben ser mayúsculas

Literales enteros

Veamos algunos ejemplos de números enteros:

>>> 8
8
>>> 0
0
>>> 08
File "<stdin>", line 1
08
^
SyntaxError: invalid token
>>> 99
99
>>> +99
99
>>> -99
-99
>>> 3000000
3000000
>>> 3_000_000
3000000

Dos detalles a tener en cuenta:

• No podemos comenzar un número entero por 0.
• Python permite dividir los números enteros con guiones bajos _ para clarificar su
lectura/escritura. A efectos prácticos es como si esos guiones bajos no existieran.

Con editor

num=3_000_000
print(num)

salida
3000000

Operaciones con enteros

Prioridad de los operadores

Ejemplos de prioridad de operadores:

>>> 2 ** 2 + 4 / 2
6.0
>>> 2 ** (2 + 4) / 2
32.0

Asignación aumentada

Mezcla el operador de asignación con un operador aritmético

Asignación Tradicional

a = a + 10

Asignación aumentada

a += 10

Tradicional
a=a*4
Aumentada
a*=4

>>> total_cars = total_cars - sold_cars

>>> total_cars -= sold_cars

Ejemplos

>>> random_number = 15
>>> random_number += 5
>>> random_number
20
>>> random_number *= 3
>>> random_number
60
>>> random_number //= 4
>>> random_number
15
>>> random_number **= 1
>>> random_number
15

Ejemplo operación residuo o módulo

>>> dividendo = 17
>>> divisor = 5
>>> cociente = dividendo // divisor # división entera
>>> resto = dividendo % divisor
>>> cociente
3
>>> resto
2

Valor absoluto

Python ofrece la función abs() para obtener el valor absoluto de un número:

>>> abs(-1)
1
>>> abs(1)
1
>>> abs(-3.14)
3.14
>>> abs(3.14)
3.14

Límite de un entero
El limite de un entero es de cualquier tamaño.
Ejemplo, supongamos que queremos representar un centillón. Este valor viene a ser un
«1» seguido por ¡600 ceros! ¿Será capaz Python de almacenarlo?
>>> centillion = 10 ** 600
>>> centillion
100000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000 ……

Flotantes
Los números en punto flotante3 tienen parte decimal. Veamos algunos ejemplos de
flotantes en Python.

Distintas formas de escribir el flotante 4.0

>>> 4.0
4.0
>>> 4.
4.0
>>> 04.0
4.0
>>> 04.
4.0
>>> 4.000_000
4.0
>>> 4e0 # 4.0 * (10 ** 0)
4.0
Conversión implícita
Cuando mezclamos enteros, booleanos y flotantes, Python realiza automáticamente una
conversión implícita (o promoción) de los valores al tipo de «mayor rango». Veamos
algunos ejemplos de esto:

>>> True + 25
26
>>> 7 * False
0
>>> True + False
1
>>> 21.8 + True
22.8
>>> 10 + 11.3
21.3

La siguiente tabla muestra las conversiones cuando se trabaja con tipo bool y números

Conversión explícita
Existen una serie de funciones para realizar conversiones explícitas de un tipo a otro:

bool() Convierte el tipo a booleano.

int() Convierte el tipo a entero.
float() Convierte el tipo a flotante.
Veamos algunos ejemplos de estas funciones:
>>> bool(1)
True
>>> bool(0)
False
>>> int(True)
1
>>> int(False)
0
>>> float(1)
1.0
>>> float(0)
0.0
>>> float(True)
1.0
>>> float(False)
0.0

En el caso de que usemos la función int() sobre un valor flotante, nos retorna su parte

𝑖𝑛𝑡(25.5) =25
baja:

Redondear un valor round()

>>> pi = 3.14159265359
>>> round(pi)
3
>>> round(pi, 1)
3.1
>>> round(pi, 2)
3.14
>>> round(pi, 3)
3.142
>>> round(pi, 4)
3.1416
>>> round(pi, 5)
3.14159

Nota: round() aproxima al valor más cercano, mientras que int() obtiene siempre
el entero «por abajo».

Límite de un flotante
A diferencia de los enteros, los números flotantes sí que tienen un límite en Python. Para
descubrirlo podemos ejecutar el siguiente código:

>>> import sys

>>> sys.float_info.min
2.2250738585072014e-308

>>> sys.float_info.max
1.7976931348623157e+308
Bases

3.2.4 Bases
Los valores numéricos con los que estamos acostumbrados a trabajar están en base 10
(o decimal). Esto indica que disponemos de 10 «símbolos» para representar las
cantidades. En este caso del 0 al 9.
Pero también es posible representar números en otras bases. Python nos ofrece una
serie de prefijos y funciones para este cometido.

Base binaria
Cuenta con 2 símbolos para representar los valores: 0 y 1.

Prefijo: 0b
>>> 0b1001
9
>>> 0b1100
12

Función: bin()
>>> bin(9)
‘0b1001’
>>> bin(12)
‘0b1100’

Base octal
Cuenta con 8 símbolos para representar los valores: 0, 1, 2, 3, 4, 5, 6 y 7.
Prefijo: 0o
>>> 0o6243
3235
>>> 0o1257
687
Función: oct()
>>> oct(3235)
‘0o6243’
>>> oct(687)
‘0o1257’

Base hexadecimal
Cuenta con 16 símbolos para representar los valores: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D,
E y F.
Prefijo: 0x
>>> 0x7F2A
32554
>>> 0x48FF
18687

Función: hex()
>>> hex(32554)
‘0x7f2a’
>>> hex(18687)
‘0x48ff’

Cadenas de texto
Las cadenas de texto son secuencias de caracteres. También se les conoce como
«strings» y nos permiten almacenar información textual de forma muy cómoda.
Es importante destacar que Python 3 almacena los caracteres codificados en el estándar
Unicode, lo que es una gran ventaja con respecto a versiones antiguas del lenguaje.

Creando «strings»
Para escribir una cadena de texto en Python basta con rodear los caracteres con comillas
simples:
>>> ‘Mi primera cadena en Python’
‘Mi primera cadena en Python’

Para incluir comillas dobles dentro de la cadena de texto no hay mayor inconveniente:
>>> ‘Los llamados "strings" son secuencias de caracteres’
‘Los llamados "strings" son secuencias de caracteres’

Comillas simples escapadas

>>> ‘Los llamados \’strings\’ son secuencias de caracteres’
"Los llamados ‘strings’ son secuencias de caracteres"

Comillas simples dentro de comillas dobles

>>> "Los llamados ‘strings’ son secuencias de caracteres"

"Los llamados ‘strings’ son secuencias de caracteres"

Conversión
Podemos crear «strings» a partir de otros tipos de datos usando la función str():
>>> str(True)
‘True’
>>> str(10)
‘10’
>>> str(21.7)
‘21.7’
Para el caso contrario de convertir un «string» a un valor numérico, tenemos a disposición
las funciones ya vistas:
>>> int(‘10’)
10
>>> float(‘21.7’)
21.7
Pero hay que tener en cuenta un detalle. La función int() también admite la base en la
que se encuentra el número. Eso significa que podemos pasar un número, por ejemplo,
en hexadecimal (como «string») y lo podríamos convertir a su valor entero:
>>> int(‘FF’, 16)
255

Nota: La base por defecto que utiliza int() para convertir cadenas de texto es la base
decimal.

Secuencias de escape
Python permite escapar el significado de algunos caracteres para conseguir otros
resultados.
Si escribimos una barra invertida \ antes del carácter en cuestión, le otorgamos un
significado especial.
Quizás la secuencia de escape más conocida es \n que representa un salto de línea, pero
existen muchas otras:

# Salto de línea
>>> msg = ‘Primera línea\nSegunda línea\nTercera línea’
>>> print(msg)
Primera línea
Segunda línea
Tercera linea

# Tabulador
>>> msg = ‘Valor = \t40’
>>> print(msg)
Valor = 40

# Comilla simple
>>> msg = ‘Necesitamos \’escapar\’ la comilla simple’
>>> print(msg)
Necesitamos ‘escapar’ la comilla simple

# Barra invertida
>>> msg = ‘Capítulo \\ Sección \\ Encabezado’
>>> print(msg)
Capítulo \ Sección \ Encabezado

Nota: Al utilizar la función print() es cuando vemos realmente el resultado de utilizar los
caracteres escapados.

Leer datos desde teclado

Python también nos ofrece la posibilidad de leer la información introducida por teclado.
Para ello se utiliza la función input():

>>> name = input(‘Introduzca su nombre: ‘)

Introduzca su nombre: Sergio
>>> name
‘Sergio’
>>> type(name)
<class ‘str’>
>>> age = input(‘Introduzca su edad: ‘)
Introduzca su edad: 41
>>> age
‘41’
>>> type(age)
<class ‘str’>

Nota: La función input() siempre devuelve un objeto de tipo cadena de texto o str.
Tenerlo muy en cuenta a la hora de trabajar con números, ya que debemos realizar una
conversión explícita.

Ejemplo

>>> age = int(input(‘Introduzca su edad: ‘))

Introduzca su edad: 41
>>> age
41
>>> type(age)
<class ‘int’>
Ejercicio
Escriba un programa en Python que lea por teclado dos números enteros y muestre por
pantalla el resultado de realizar las operaciones básicas entre ellos.

Operaciones con Cadenas

Combinar cadenas
Podemos combinar dos o más cadenas de texto utilizando el operador +:
>>> proverb1 = ‘Cuando el río suena’
>>> proverb2 = ‘agua lleva’
>>> proverb1 + proverb2
‘Cuando el río suenaagua lleva’
>>> proverb1 + ‘, ‘ + proverb2 # incluimos una coma
‘Cuando el río suena, agua lleva’
Repetir cadenas
Podemos repetir dos o más cadenas de texto utilizando el operador *:
>>> reaction = ‘Wow’
>>> reaction * 4
‘WowWowWowWow’

Obtener un carácter
Los «strings» están indexados y cada carácter tiene su propia posición. Para obtener un
único carácter dentro de una cadena de texto es necesario especificar su índice dentro de
corchetes [...].

>>> sentence = ‘Hola, Mundo’

>>> sentence[0]
‘H’
>>> sentence[-1]
‘o’
>>> sentence[4]
‘,’
>>> sentence[-5]
‘M’

Las cadenas de texto son tipos de datos inmutables. Es por ello que no podemos
modificar un carácter directamente:

Trocear una cadena

Es posible extraer «trozos» de una cadena de texto2. Se tienen varias aproximaciones
para ello:
[:] Extrae la secuencia entera desde el comienzo hasta el final. Es una especia de copia
de toda la cadena de texto.
[start:] Extrae desde start hasta el final de la cadena.
[:end] Extrae desde el comienzo de la cadena hasta end menos 1.
[start:end] Extrae desde start hasta end menos 1.
[start:end:step] Extrae desde start hasta end menos 1 haciendo saltos de tamaño step.
Veamos la aplicación de cada uno de estos accesos a través de un ejemplo:

>>> proverb = ‘Agua pasada no mueve molino’

>>> proverb[:]
‘Agua pasada no mueve molino’
>>> proverb[12:]
‘no mueve molino’
>>> proverb[:11]
‘Agua pasada’
>>> proverb[5:11]
‘pasada’
>>> proverb[5:11:2]
‘psd’

Importante: El troceado siempre llega a una unidad menos del índice final que hayamos
especificado. Sin embargo el comienzo sí coincide con el que hemos puesto.

Control de flujo

Normalmente el control de flujo se hace en forma secuencial de arriba hacia abajo, pero
hay acciones que hacen que este comportamiento no se dé. Las siguientes instrucciones
que presentan este comportamiento son las siguientes;
Condicionales

En esta sección veremos las sentencias if y match-case junto a las distintas variantes
que pueden asumir, pero antes de eso introduciremos algunas cuestiones generales de
escritura de código

Definición de bloques
A diferencia de otros lenguajes que utilizan llaves para definir los bloques de código,
en Python los bloques de código se definen a través de espacios en blanco,
preferiblemente 4. En términos técnicos se habla del tamaño de indentación

Comentarios
Los comentarios son anotaciones que se pueden incluir en el programa y que permiten
aclarar ciertos aspectos del código. Estas indicaciones son ignoradas por el intérprete de
Python.
Los comentarios se incluyen usando el símbolo almohadilla # y comprenden hasta el final
de la línea.

Comentario en bloque
#Esto es un comentario para clarificar acciones

Comentario en línea
stock = cantidad_minima #determina cantidad mínima en bodega

La sentencia if
La sentencia condicional en Python (al igual que en muchos otros lenguajes de
programación) es if. En su escritura debemos añadir una expresión de comparación
terminando con dos puntos al final de la línea. Veamos un ejemplo

Formato

If condición:
Acciones por verdadero
[else:
Acciones por falso]

>>> temperature = 20

>>> if temperature > 35:

... print(‘Aviso por alta temperatura’)
... else:
... print(‘Parámetros normales’)
...

Parámetros normales

Decisiones anidadas
>>> temperature = 28
>>> if temperature < 20:
... if temperature < 10:
... print(‘Nivel azul’)
... else:
... print(‘Nivel verde’)
... else:
... if temperature < 30:
... print(‘Nivel naranja’)
... else:
print(‘Nivel rojo’)

Nivel naranja

Python nos ofrece una mejora en la escritura de condiciones anidadas cuando aparecen
consecutivamente un else y un if. Podemos sustituirlos por la sentencia elif:
>>> temperature = 28
>>> if temperature < 20:
... if temperature < 10:
... print(‘Nivel azul’)
... else:
... print(‘Nivel verde’)
... elif temperature < 30:
... print(‘Nivel naranja’)
... else:
... print(‘Nivel rojo’)
...
Nivel naranja

Operadores de comparación
Ejemplos con lo operadores

# Asignación de valor inicial

>>> value = 8
>>> value == 8
True
>>> value != 8
False
>>> value < 12
True
>>> value <= 7
False
>>> value > 4
True
>>> value >= 9
False

Operadores lógicos
• and
• or
• not

Ejemplo
# Asignación de valor inicial
>>> x = 8
>>> x > 4 or x > 12 # True or False
True
>>> x < 4 or x > 12 # False or False
False
>>> x > 4 and x > 12 # True and False
False

True
Para determinar el resultado de una expresión lógica se deben tener bien claro las tablas
de decisión.

Python a diferencia de otros lenguajes, ofrece la posibilidad de ver si un valor está entre
dos límites de manera directa. Así, por ejemplo, para descubrir si value está entre 4 y 12
haríamos:
>>> 4 <= value <= 12
True
>>> x=8

>>> 4<x<12 # True or False

True

Funciona con and

Ejecución paso a paso

ejemplo anterior queda

«Booleanos» en condiciones
Cuando queremos preguntar por la veracidad de una determinada variable «booleana»
en una condición, la primera aproximación que parece razonable es la siguiente:
>>> is_cold = True
>>> if is_cold == True:
... print(‘Coge chaqueta’)
... else:
... print(‘Usa camiseta’)
...
Coge chaqueta
Pero podemos simplificar esta condición tal que así:
>>> if is_cold:
... print(‘Coge chaqueta’)
... else:
... print(‘Usa camiseta’)
...
Coge chaqueta

Ciclos o bucles
sentencia while.
Formato

while condición:
acciones dentro del ciclo

Mientras la condición sea verdadera realice las acciones dentro del ciclo

Veamos un sencillo bucle que muestra por pantalla los números del 1 al 4:

>>> value = 1
>>> while value <= 4:
... print(value)
... value += 1
...
1
2
3
4

Romper un bucle while

Antes de que la condición se vuelva falsa, se puede romper un ciclo utilizando la

sentencia break

Cuando se encuentra la sentencia break se sale del ciclo porque la condición se vuelve
falsa
Ejemplo: buscar un número múltiplo de 3 desde 20 hasta 1. Cuando encuentre el primer
multiplo de 3 salir del bucle.

>>> num = 20
>>> while num >= 1:
... if num % 3 == 0:
... print(num)
... break
... num -= 1
...
18

Continuar un bucle
Saltar adelante hacia la siguiente repetición.
Sentencia continue.
Cuando dentro de las instrucciones se encuentran la sentencia continue, el control de
ejecución regresa a evaluar la condición del ciclo, saltándose las acciones que faltaran en
la iteración.
En resumen, se descartar el resto del código del ciclo y salta a la siguiente iteración.

Ejemplo mostrar los valores del 1 al 20 excepto los múltiplos de 3

En el ejercicio cada vez que se encuentra un múltiplo de 3 salta a evaluar la condición
para la siguiente iteración.

>>> num = 21
>>> while num >= 1:
... num -= 1
... if num % 3 == 0:
... continue
... print(num, end=’, ‘) # Evitar salto de línea
...
20, 19, 17, 16, 14, 13, 11, 10, 8, 7, 5, 4, 2, 1,

Bucles infinitos
Cuando no se controla bien la condición o no se cumple adecuadamente dentro de las
instrucciones a repetirse la posibilidad de volver la condición falsa entonces se genera un
bucle infinito
Ejemplo

>>> num = 1
>>> while num != 10:
... num += 2
...

Lo infinito se puede interrumpir con CTRL-C

El problema que surge es que la variable num toma los valores 1, 3, 5, 7, 9, 11, ..
. por lo que nunca se cumple la condición de parada del bucle. Esto hace que se repita la
ejecución
Una posible solución a este error es reescribir la condición de parada en el bucle:
>>> num = 1
>>> while num < 10:
... num += 2
...

Hay veces en que la condición se la puede reemplazar con True y dentro del ciclo forzar
la salida.
Ejemplo

>>>while True:
... mark = float(input(‘Introduzca nueva nota: ‘))
... if not(0 <= mark <= 10):
... print(´Nota fuera de rango’)
... break
... print(mark)
...

Ejecución
Introduzca nueva nota: 5
5.0
Introduzca nueva nota: 3
3.0
Introduzca nueva nota: 11
Nota fuera de rango

La sentencia for
Python permite recorrer aquellos tipos de datos que sean iterables, es decir, que admitan
ser recorridas, utilizando la sentencia for.
Algunos ejemplos de tipos y estructuras de datos que permiten ser iteradas (recorridas)
son: cadenas de texto, listas, diccionarios, ficheros, etc.

La sentencia for permite realizar esta acción.

Formato

for variable in estructura de datos iterable :

Acciones dentro del ciclo

Variable va a tomar todos los valores de la estructura de datos iterable

Ejemplo: recorrer un cadena de texto con for

>>> word = ‘Python’
>>> for letter in word:
... print(letter)
...
P
y
t
h
o
n

letter toma en cada iteración una de las letras que existen en word, porque una cadena de
texto está formada por elementos que son caracteres e internamente cada carácter tiene
un índice asociado (contador 0…tam-1).

Secuencias de números

Es muy habitual hacer uso de secuencias de números en bucles. Python no tiene una
instrucción específica para ello. Lo que sí aporta es una función range() que devuelve un
flujo de números en el rango especificado. Una de las grandes ventajas es que la «lista»
generada no se construye explícitamente, sino que cada valor se genera bajo demanda.
Esta técnica mejora el consumo de recursos, especialmente en términos de memoria.

Formato función range():

range(start, stop,step):
• start: Es opcional y tiene valor por defecto 0.
• stop: es obligatorio (siempre se llega a 1 menos que este valor).
• step: es opcional y tiene valor por defecto 1.
range( La variable puede ser cualquier nombre

Rango: [0, 1, 2]

>>> for i in range(0, 3):

... print(i)
...
0
1
2
>>> for i in range(3): # No hace falta indicar el inicio si es 0
... print(i)
...
0
1
2

Utilización de variable

>>> c=4
>>> for i in range(c): # No hace falta indicar el inicio si es 0
... print(i)
...
0
1
2
3

Con paso diferente a 1

Variación de 2

Rango: [1, 3, 5]

>>> for i in range(1, 6, 2):

... print(i)
...
1
3
5

Variación de -1
Rango: [2, 1, 0]

>>> for i in range(2, -1, -1):

... print(i)
...
2
1
0

Bucles anidados

>>> for i in range(1, 10):

... for j in range(1, 10):
... result = i * j
... print(f’{i} * {j} = {result}’)
...
1x1=1
1x2=2
1x3=3
1x4=4
1x5=5
1x6=6
1x7=7
1x8=8
1x9=9
2x1=2
2x2=4
2x3=6
2x4=8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18
….

Estructuras de datos
Listas

Las listas permiten almacenar objetos mediante un orden definido y con

posibilidad de duplicados. Las listas son estructuras de datos mutables, lo que
significa que podemos añadir, eliminar o modificar sus elementos
Creación de listas
Una lista está compuesta por cero o más elementos. En Python debemos escribir
estos elementos separados por comas y dentro de corchetes. Veamos algunos
ejemplos de listas:

>>> empty_list = []
>>> languages = [‘Python’, ‘Ruby’, ‘Javascript’]
>>> fibonacci = [0, 1, 1, 2, 3, 5, 8, 13]
>>> data = [‘Tenerife’, {‘cielo’: ‘limpio’, ‘temp’: 24}, 3718, (28.2933947, -16.
˓→5226597)]

Nota: Una lista puede contener tipos de datos heterogéneos, lo que la hace una
estructura de datos muy versátil.

Conversión función list()

Para convertir otros tipos de datos en una lista podemos usar la función list():
>>> # conversión desde una cadena de texto
>>> list(‘Python’)

[‘P’, ‘y’,’t’,’h’,’o’,’n’]

Podemos extender este comportamiento a cualquier otro tipo de datos que permita
ser iterado (iterables).

Combinación de range() con list(). Obtener una lista explícita con los valores que
constituyen el rango [0, 9]:

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Lista vacía
Existe una manera particular de usar list() y es no pasarle ningún argumento.

vacía:
>>> list()
[]

Para crear una lista vacía, se suele recomendar el uso de [] frente a list(), mejor
rendimiento en tiempos de ejecución.

Operaciones con listas

Obtener un elemento
Igual que en el caso de las cadenas de texto, podemos obtener un elemento de
una lista a través del índice (lugar) que ocupa. Veamos un ejemplo:
>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’]
>>> shopping[0]
‘Agua’
>>> shopping[1]
‘Huevos’
>>> shopping[2]
‘Aceite’
>>> shopping[-1] # acceso con índice negativo
‘Aceite’

El índice tiene que estar comprendido entre los límites de la misma. Si no es así,
hay un error (excepción):

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’]

>>> shopping[3]

Traceback (most recent call last):

File "<stdin>", line 1, in <module>
IndexError: list index out of range

>>> shopping[-5]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range

Trocear una lista

El troceado de listas funciona de manera totalmente análoga al troceado de
cadenas. Veamos algunos ejemplos:

>>> shopping = [‘Agua‘, ‘Huevos‘, ‘Aceite‘, ‘Sal‘, ‘Limón‘]

>>> shopping[0:3]

[‘Agua‘, ‘Huevos‘, ‘Aceite‘]

>>> shopping[:3]
[‘Agua‘, ‘Huevos‘, ‘Aceite‘]

>>> shopping[2:4]
[‘Aceite‘, ‘Sal‘]

>>> shopping[-1:-4:-1]
[‘Limón‘, ‘Sal‘, ‘Aceite‘]

>>> # Equivale a invertir la lista

>>> shopping[::-1]

[‘Limón‘, ‘Sal‘, ‘Aceite‘, ‘Huevos‘, ‘Agua‘]

En el troceado de listas, no importan los índices inválidos (fuera de rango) ya que

Python los restringirá a los límites de la lista:

>>> shopping
shopping = [‘Agua‘, ‘Huevos‘, ‘Aceite‘, ‘Sal‘, ‘Limón‘]
>>> shopping[10:]
[]
>>> shopping[-100:2]
[‘Agua’, ‘Huevos’]

>>> shopping[2:100]
[‘Aceite’, ‘Sal’, ‘Limón’]

Importante: Ninguna de las operaciones anteriores modifican la lista original,

simplemente devuelven una lista nueva.

invertir una lista

Tres mecanismos para invertir los elementos de una lista:

Conservando la lista original:

Opción 1: Mediante troceado de listas con step negativo:

>>> shopping
[‘Agua‘, ‘Huevos‘, ‘Aceite‘, ‘Sal‘, ‘Limón‘]

>>> shopping[::-1]
[‘Limón‘, ‘Sal‘, ‘Aceite‘, ‘Huevos‘, ‘Agua‘]

Opción 2: Mediante la función reversed():

>>> shopping
[‘Agua‘, ‘Huevos‘, ‘Aceite‘, ‘Sal‘, ‘Limón‘]

>>> list(reversed(shopping))
[‘Limón‘, ‘Sal‘, ‘Aceite‘, ‘Huevos‘, ‘Agua‘]

Modificando la lista original: Utilizando la función reverse() (nótese que es sin

«d» al final):
>>> shopping
[‘Agua‘, ‘Huevos‘, ‘Aceite‘, ‘Sal‘, ‘Limón‘]

>>> shopping.reverse()

>>> shopping
[‘Limón‘, ‘Sal‘, ‘Aceite‘, ‘Huevos‘, ‘Agua‘]

Añadir al final de la lista función append()

Una de las operaciones más utilizadas en listas es añadir elementos al final de las
mismas.
Para ello Python nos ofrece la función append(). Se trata de un método destructivo
que modifica la lista original:

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’]

>>> shopping.append(‘Atún’)
>>> shopping
[‘Agua’, ‘Huevos’, ‘Aceite’, ‘Atún’]

Creando desde vacío

Una forma muy habitual de trabajar con listas es empezar con una vacía e ir
añadiendo elementos poco a poco. Se podría hablar de un patrón creación.
Supongamos un ejemplo en el que queremos construir una lista con los números
pares del [0, 20):

>>> even_numbers = []
>>> for i in range(20):
... if i % 2 == 0:
... even_numbers.append(i)
...
>>> even_numbers
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Añadir en cualquier posición de una lista función insert()

La función insert() permite incorporar elementos en cualquier posición. Se debe
especificar el índice de inserción y el elemento en cuestión.

También se trata de una función destructiva:

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’]

>>> shopping.insert(1, ‘Jamón’)
>>> shopping

[‘Agua’, ‘Jamón’, ‘Huevos’, ‘Aceite’]

>>> shopping.insert(3, ‘Queso’)
>>> shopping
[‘Agua’, ‘Jamón’, ‘Huevos’, ‘Queso’, ‘Aceite’]

Nota: El índice que especificamos en la función insert() lo podemos intepretar

como la posición delante (a la izquierda) de la cual vamos a colocar el nuevo valor
en la lista.

En la función insert() no hay un error si el índice no está dentro de los límites, los
ajusta a la lista

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’]

>>> shopping.insert(100, ‘Mermelada’)
>>> shopping

[‘Agua’, ‘Huevos’, ‘Aceite’, ‘Mermelada’]

>>> shopping.insert(-100, ‘Arroz’)

>>> shopping
[‘Arroz,‘Agua’, ‘Huevos’, ‘Aceite’, ‘Mermelada’]

Consejo: Aunque es posible utilizar insert() para añadir elementos al final de

una
lista, siempre se recomienda usar append() por su mayor legibilidad:

>>> values = [1, 2, 3]

>>> values.append(4)
>>> values
[1, 2, 3, 4]

>>> values = [1, 2, 3]

>>> values.insert(len(values), 4) # don􀀉t do it!
>>> values
[1, 2, 3, 4]

Función len() entrega el tamaño de la lista

Repetir elementos
Al igual que con las cadenas de texto, el operador * nos permite repetir los
elementos de una
lista:
>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’]
>>> shopping * 3
[‘Agua’,
‘Huevos’,
‘Aceite’,
‘Agua’,
‘Huevos’,
‘Aceite’,
‘Agua’,
‘Huevos’,
‘Aceite’]

Combinar listas
Python nos ofrece dos aproximaciones para combinar listas:

Conservando la lista original: Mediante el operador + o +=:

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’]
>>> fruitshop = [‘Naranja’, ‘Manzana’, ‘Piña’]
>>> shopping + fruitshop
[‘Agua’, ‘Huevos’, ‘Aceite’, ‘Naranja’, ‘Manzana’, ‘Piña’]

Modificando la lista original: Mediante la función extend():

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’]
>>> fruitshop = [‘Naranja’, ‘Manzana’, ‘Piña’]
>>> shopping.extend(fruitshop)
>>> shopping

[‘Agua’, ‘Huevos’, ‘Aceite’, ‘Naranja’, ‘Manzana’, ‘Piña’]

Hay que tener en cuenta que extend() funciona adecuadamente si pasamos una
lista como argumento. En otro caso, quizás los resultados no sean los
esperados. Veamos un ejemplo:
>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’]
>>> shopping.extend(‘Limón’)
>>> shopping

[‘Agua’, ‘Huevos’, ‘Aceite’, ‘L’, ‘i’, ‘m’, ‘ó’, ‘n’]

El motivo es que extend() «recorre» (o itera) sobre cada uno de los elementos del
objeto en cuestión. En el caso anterior, al ser una cadena de texto, está formada
por caracteres.
Se podría pensar en el uso de append() para combinar listas. La realidad es que
no funciona exactamente como esperamos; la segunda lista se añadiría como una
sublista de la principal:

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’]

>>> fruitshop = [‘Naranja’, ‘Manzana’, ‘Piña’]
>>> shopping.append(fruitshop)
>>> shopping
[‘Agua’, ‘Huevos’, ‘Aceite’, [‘Naranja’, ‘Manzana’, ‘Piña’]]

Modificar una lista

Del mismo modo que se accede a un elemento utilizando su índice, también
podemos modificarlo:
>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’]
>>> shopping[0]
‘Agua’

>>> shopping[0] = ‘Jugo’

>>> shopping

[‘Jugo’, ‘Huevos’, ‘Aceite’]

En el caso de acceder a un índice no válido de la lista, incluso para modificar,

obtendremos un error:

>>> shopping[100] = ‘Chocolate’

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range

Modificar con troceado

No sólo es posible modificar un elemento de cada vez, sino que podemos asignar
valores a trozos de una lista:
>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]
>>> shopping[1:4]
[‘Huevos’, ‘Aceite’, ‘Sal’]

>>> shopping[1:4] = [‘Atún’, ‘Pasta’]

>>> shopping

[‘Agua’, ‘Atún’, ‘Pasta’, ‘Limón’]

Nota: La lista que asignamos no necesariamente debe tener la misma longitud

que el trozo que sustituimos.
Borrar elementos
Python nos ofrece, al menos, cuatro formas para borrar elementos en una lista:

Por su índice: Mediante la función del():

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]
>>> del(shopping[3])
>>> shopping
[‘Agua’, ‘Huevos’, ‘Aceite’’, ‘Limón’]

Por su valor: Mediante la función remove():

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]
>>> shopping.remove(‘Sal’)
>>> shopping
[‘Agua’, ‘Huevos’, ‘Aceite’, ‘Limón’]

Advertencia: Si existen valores duplicados, la función remove() sólo borrará la

primera ocurrencia.

Por su índice (con extracción): Las dos funciones anteriores del() y remove()
efectivamente borran el elemento indicado de la lista, pero no «devuelven» nada.
Sin embargo, Python nos ofrece la función pop() que además de borrar, nos
«recupera» el elemento; algo así como una extracción. Lo podemos ver como una
combinación de acceso + borrado:

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]

>>> shopping.pop()
‘Limón’
>>> shopping

[‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’]

>>> shopping.pop(2)
‘Aceite’
>>> shopping
[‘Agua’, ‘Huevos’, ‘Sal’]
Nota: Si se usa la función pop() sin pasarle ningún argumento, por defecto usará
el índice -1, es decir, el último elemento de la lista. Pero también podemos
indicarle el índice del elemento a extraer.

Por su rango: Mediante troceado de listas:

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]
>>> shopping[1:4] = []
>>> shopping
[‘Agua’, ‘Limón’]

Borrado completo de la lista

Python nos ofrece, al menos, dos formas para borrar una lista por completo:
1. Utilizando la función clear():
>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]
>>> shopping.clear() # Borrado in-situ
>>> shopping
[]
2. «Reinicializando» la lista a vacío con []:

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]

>>> shopping = [] # Nueva zona de memoria
>>> shopping
[]

Encontrar un elemento funcion index()

Si queremos descubrir el índice que corresponde a un determinado valor dentro la
lista podemos usar la función index() para ello:

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]

>>> shopping.index(‘Huevos’)
1
Tener en cuenta que si el elemento que buscamos no está en la lista,
obtendremos un error:
>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]
>>> shopping.index(‘Pollo’)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>
ValueError: ‘Pollo’ is not in list

pertenencia de un elemento
Si se quiere comprobar la existencia de un determinado elemento en una lista,
podríamos buscar su índice, o utilizar el operador in:
>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]
>>> ‘Aceite’ in shopping
True
>>> ‘Pollo’ in shopping
False
Nota: El operador in siempre devuelve un valor booleano, es decir, verdadero o
falso.

Número de ocurrencias
Para contar cuántas veces aparece un determinado valor dentro de una lista
podemos usar la función count():
>>> sheldon_greeting = [‘Penny’, ‘Penny’, ‘Penny’]
>>> sheldon_greeting.count(‘Howard’)
0
Ordenar una lista
Python proporciona, al menos, dos formas de ordenar los elementos de una lista:
Conservando lista original: Mediante la función sorted() que devuelve una nueva
lista ordenada:
>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]
>>> sorted(shopping)
[‘Aceite’, ‘Agua’, ‘Huevos’, ‘Limón’, ‘Sal’]
Modificando la lista original: Mediante la función sort():
>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]
>>> shopping.sort()
>>> shopping
[‘Aceite’, ‘Agua’, ‘Huevos’, ‘Limón’, ‘Sal’]

Ambos métodos admiten un parámetro «booleano» reverse para indicar si

queremos que la ordenación se haga en sentido inverso:
>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]
>>> sorted(shopping, reverse=True)

[‘Sal’, ‘Limón’, ‘Huevos’, ‘Agua’, ‘Aceite’]

Longitud de una lista

La función len() permite establecer el tamaño de la lista:
>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]
>>> len(shopping)
5

Ejercicios con listas de datos numéricos

Ejercicio 1
Llenar una lista con datos numéricos con datos repetidos y formar una nueva lista con los
datos sin repetidos ordenada ascendentemente y descendentemente.

Ejemplo

Cantidad de datos 8

Datos
[7,2,7,3,2,4,2,7]

Resultado
[7,2,3,4]
Resultado ascendente
[2,3,4,7]

Resultado descendente
[7,4,3,2]

#Lista de datos no repetidos en forma ascendente y descendente

cd1=int(input('Cantidad de datos -> '))

l1=[]
l2=[] #l2 lista resultado sin repetidos

#llenar lista con datos enteros por el teclado

for i in range(cd1):
l1.append(int(input('dato '+str(i)+ '-> ')))

#mostrar lista digitada

print('Lista digitada \n',l1)

#recorrer l1 y por cada dato llenarlo en l2 si no está

for i in range(len(l1)):
b=l1[i] in l2 #en b se determina si el dato l1[i] está en lista l2
if b==False:
l2.append(l1[i])

print('lista sin repetidos \n',l2)

l2.sort()

print('lista sin repetidos ordenada \n',l2)

l2.sort(reverse=True)
print('lista sin repetidos ordenada descendentemente \n',l2)

Ejercicio 2
Se tiene una lista con enteros repetidos, determinar cuantas veces aparece cada dato en
la lista.
En este ejercicio, no se van a leer los datos desde el teclado, ya están definidos. Si se lo
quiere generalizar se llenan los datos desde el teclado
Ejemplo
lista=[7,2,7,3,2,4,2,7]

Resultado

7 4 veces
2 3 veces
3 1 veces
4 1 veces

#Contar las veces que aparecen los datos en la lista

#Los datos de la lista se los define directamente
#La lista l2 controla los datos que se van contando para no repetir la cuenta

l1=[7,2,7,3,2,4,2,7]
l2=[] # esta lista va a controlar los que se van contado

for i in range(len(l1)):
b=l1[i] in l2 #determina en b si l1[i] está en la lista l2
 if b==False:
c=l1.count(l1[i]) #se cuenta las veces que aparece l1[i] en l1
# muestra el dato y su cuenta
print('dato ',l1[i], 'esta ',c,' veces')
l2.append(l1[i]) # se adiciona en l2 para indicar que ya se contó

Ejercicio 3
Se tiene una lista con datos numéricos, eliminar los números pares de la lista.
La lista se la define
Ejemplo

[7,2,7,3,2,4,2,7]

Resultado
[7,7,3,7]

#Eliminar los números pares de una lista

#Definer directamente la listas

l1=[7,2,7,3,2,4,2,7]
i=0
while i<len(l1):
if l1[i]%2==0:
del(l1[i])
else:
i=i+1
print('Lista resultante \n',l1)

Ejercicio 4
Se tiene una lista con datos numéricos ordenada ascendentemente, insertar un nuevo
dato en la posición que le corresponde de forma tal que siga ordenada. No aplicar método
de ordenamiento.

Ejemplo.
Lista inicial
[4,4,15,20,20,25,30]
Dato a insertar
28
Lista resultante
[4,4,15,20,20,25,28,30]
Pasos genéricos

Definir lista ordenada

Determinar dato a insertar
Ubicar posición correspondiente
Insertar dato
Mostrar lista
El programa es para el ejemplo planteado si se va a generalizar se debe digitar los datos
de la lista por el teclado, como el ejercicio 1.

#insertar dato en una lista ordenada

lo=[4,4,15,20,20,25,30]
#dato a insertar
dato=int(input('Dato a insertar '))
#ubicar posición
i=0
while i<len(lo):
if dato>lo[i]:
i=i+1
else:
break
#la posición donde se inserta es i
lo.insert(i,dato)
#mostrar lista
print('Lista ordenada \n',lo)

Ejercicio 5.
Se tiene una cantidad de datos dada que entran desde el teclado. Llenarlos en una lista,
de forma tal que al entrar vayan quedando ordenados ascendentemente. (ordenamiento
por inserción)

Ejemplo
7 datos
9 4 6 2 14 3 1
Después de entrado los datos, la lista queda
[1, 2, 3, 4, 6, 9, 14]
Para este ejercicio se utiliza la lógica del anterior. Los pasos genéricos son los siguientes

Definir lista resultante

Leer cantidad de datos
Entrada desde el teclado de los datos y por cada dato realizar
Insertar dato en lista ordenada
Ubicar posición
Insertar dato en la posición
Mostrar lista ordenada

#Ordenar una lista por inserción

lo=[]
cd=int(input('Cantidad de datos a ingresar -> '))
j=1
while j<=cd:
dato=int(input('Digitar dato -> '))
#buscar posición en lista lo
i=0
while i<len(lo):
 if dato>lo[i]:
i=i+1
else:
break
lo.insert(i,dato)
j=j+1
#mostrar lista
print('Lista ordenada \n',lo)

Ejercicio 6
Se tiene una lista con una cantidad de números. Buscar un dato dado en la lista y su
posición.
Anotaciones
Para este ejercicio se hace uso de la función index() la cual entrega la ubicación de un
elemento dentro de la lista solo si existe en la lista, si no existe el programa cancela, por
lo que se debe combinar este ejercicio preguntando primero si el dato se encuentra en la
lista (acción in) , si existe se obtiene con seguridad de no cancelar el índice.

Ejemplo

[9, 14, 3, 4, 10, 12, 1]

Dato a buscar 10

R/ 10 se encuentra en la posición 4

Pasos genéricos

Definir lista
Leer dato a buscar
Determinar si dato se encuentra en la lista
Si dato se encuentra en la lista obtener índice
Mostrar ubicación del dato
Sino se encuentra mostrar resultado

#Buscar dato y obtener indice en una lista

lista=[4,7,8,7,2,9,8]
#digitar dato a buscar
dato=int(input('Digitar dato a buscar -> '))
b=dato in lista
if b==True:
i=lista.index(dato)
print(lista)
print(dato,' se encuentra en la posición ',i,' de la lista ')
else:
print(lista)
print(dato,' no se encuentra en la lista ')
Ejercicio 7
Se tiene una lista con datos numéricos, determinar cual es el dato que más se repite.

Ejemplo

[7,4,2,9,7,4,4,7,4,2,9]

Dato que más se repite 4 4 veces.

Este ejercicio es el complemento del ejercicio que cuenta las veces que se repiten los
datos, en donde se lleva un contador del dato que no se ha contado. Por lo tanto se debe
controlar los datos contados en una lista.

Pasos genéricos

Definir lista datos

Definir lista de contados
Recorre lista datos y por cada dato realizar
Determinar si el dato se encuentra en la lista de contados
Si no está
determinar las veces que se repite
Determinar si es el primer contador
Si es el primer
Definirlo como mayor y guardar dato
Si no es el primero
Compararlo con el mayor que se lleva
realizar cambios
mostrar dato más repetido y las veces que lo hace

#Los datos de la lista se los define directamente

#La lista contados controla los datos que se van contando para no repetir la
#cuenta

datos=[7,4,2,9,7,4,4,7,4,2,9]
contados=[]
b1=0
for i in range(len(datos)):
b=datos[i] in contados #determina si l1[i] está en la lista l2
if b==False:
c=datos.count(datos[i])
if b1==0:
mayor=c
datomay=datos[i]
b1=1
else:
if c>mayor:
mayor=c
datomay=datos[i]
 #determinar dato como contado
contados.append(datos[i])
print('Dato que mas se repite -> ',datomay,' veces que se repite ->',mayor)

Ejercicio 8
Se tienen dos listas con datos numéricos formar una tercera lista con los pares no
comunes sin repetidos

Ejemplo
l1=[4,2,9,7,4,8,10,15]
l2=[10,6,7,8,16,20,6]

Lista resultado = [4,2,6,16,20]

Pasos genéricos

Definir lista 1
Definir lista 2
Recorrer lista 1 y por cada dato realizar
Determinar si dato es par
Si es par buscarlo en lista 2
Si no está buscarlo en lista resultado
Si no está llenarlo en lista resultado
Recorre lista 2 y por cada dato realizar
Determinar si dato es par
Si es par buscarlo en lista 1
Si no está buscarlo en lista resultado
Si no está llenarlo en lista resultado
Mostrar lista resultado

#formar una lista con pares no comunes de dos listas sin repetidos
#definir listas

l1=[4,2,7,9,4,8,10,15]
l2=[10,6,7,8,16,20,6]
lr=[] #lista resultado
#recorrer lista 1 y realizar...
for i in range(len(l1)):
if l1[i] % 2==0:
b=l1[i] in l2 #busca dato de l1 en l2
if b==False:
b1=l1[i] in lr #busca dato de l1 en lr
if b1==False:
lr.append(l1[i])
#recorrer lista 2 y realizar ...
for i in range(len(l2)):
if l2[i] % 2==0:
b=l2[i] in l1 #busca dato de l2 en l1
 if b==False:
b1=l2[i] in lr #busca dato de l2 en lr
if b1==False:
lr.append(l2[i])
#muestra lista resultado
print('lista pares no cumunes \n',lr)

Nota importante. La mayoría de los ejercicios no está necesitando los datos desde el
teclado, se los define directamente lo que implica que el ejercicio solo funciona para las
listas con los datos propuestos.
La generalización se logra entrando los datos desde el teclado, como se había
establecido en el primer ejercicio, o generando los números de la lista aleatoriamente.

Generación de números aleatorios.

Hasta el momento se han realizado ejercicios con listas creadas en la definición o
llenando los datos desde el teclado. El siguiente tema permite llenar listas en forma
aleatoria utilizando la clase random
La clase random brinda una serie de métodos que permiten generar números
aleatoriamente.
Las funciones o métodos más utilizados son: randint y randrange

Los siguientes ejercicios permiten la utilización de las funciones anteriores

Para poder usar estos métodos se importa la clase random

Ejercicio 1
Generar 10 números enteros aleatoriamente entre 0 y 10

import random
lista1=[]
for _ in range(10):
num=random.randint(0,10)
lista1.append(num)
print(lista1)

Ejercicio 2
Generar 10 números pares aleatorios entre 0 y 100

#ejercicio pares aleatorios

import random
list2=[]
for _ in range(10):
num=random.randrange(0,100,2)
list2.append(num)
print(list2)
ejercicio 3
Generar 10 números aleatorios múltiplos de 5
Forma 1

#aleatorios múltiplos de 3

import random
list3=[]
for _ in range(10):
num=random.randrange(0,100,5)
list3.append(random.randrange(0,100,5))
print(list3)

forma 2

import random
list3=[]
for _ in range(10):
num=random.randint(1,10)*5
list3.append(num)
print(list3)

Ejercicio 4
Generar los números del 1 al 20 desordenados

import random
list4=[]
for i in range(21):
list4.append(i)
random.shuffle(list4)
print(list4)

Ejercicio 9
Se tienen dos listas con datos numéricos generados aleatoriamente, formar una lista con
la unión de las dos por extensión.

#formar una lista con la union de dos listas. la union en lista 1

#definir listas aleatoriamente.

import random
cd1=int(input("Cantidad de datos lista 1 ->"))
cd2=int(input("Cantidad de datos lista 2 ->"))
l1=[]
l2=[]
v1=int(input("valor entero límite aleatorio ->"))

for _ in range(cd1):
l1.append(random.randint(0,v1))
for _ in range(cd2):
l2.append(random.randint(0,v1))
print("lista 1 \n",l1)
print("lista 2 \n",l2)

l1.extend(l2)

print('lista extendida en l1 \n',l1)

Ejecicio de aplicación

Se tienen dos listas con datos enteros formar una tercera lista con los pares no comunes.

Llenar las listas en forma aleatoria

Los pasos genéricos son los mismos del ejercicio anterior solo cambia la definición de las
listas que se hacen aleatoriamente.

#formar una lista con pares no comunes de dos listas sin repetidos
#definir listas. Utilizar valores aleatorios

import random
cd1=int(input("Cantidad de datos lista 1 ->"))
cd2=int(input("Cantidad de datos lista 2 ->"))
l1=[]
l2=[]
for _ in range(cd1):
l1.append(random.randint(0,20))
for _ in range(cd2):
l2.append(random.randint(0,20))
#muestra las listas a procesar
print("lista 1 \n",l1)
print("lista 2 \n",l2)
lr=[] #lista resultado
#recorrer lista 1 y realizar...
for i in range(len(l1)):
if l1[i] % 2==0:
b=l1[i] in l2
if b==False:
 b1=l1[i] in lr
if b1==False:
lr.append(l1[i])
#recorrer lista 2 y realizar ...
for i in range(len(l2)):
if l2[i] % 2==0:
b=l2[i] in l1
if b==False:
b1=l2[i] in lr
if b1==False:
lr.append(l2[i])
print('lista pares no comunes \n',lr)

Continuación con listas

Iterar sobre una lista

Al igual que con las cadenas de texto, también se puede iterar sobre los
elementos de una lista utilizando la sentencia for:

>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]

>>> for product in shopping:
... print(product)
...
Agua
Huevos
Aceite
Sal
Limón
Nota: También es posible usar la sentencia break en este tipo de bucles para
abortar su ejecución en algún momento que nos interese.

Iterar usando enumeración

Hay veces que no sólo nos interesa «visitar» cada uno de los elementos de una
lista, sino que también queremos saber su índice dentro de la misma. Para ello
Python nos ofrece la función enumerate():
>>>
>>> shopping = [‘Agua’, ‘Huevos’, ‘Aceite’, ‘Sal’, ‘Limón’]

>>> for i, product in enumerate(shopping):

... print(i, product)
...
0 Agua
1 Huevos
2 Aceite
3 Sal
4 Limón
Iterar sobre múltiples listas
Python ofrece la posibilidad de iterar sobre múltiples listas en paralelo utilizando
la función zip():

>>> shopping = [‘Agua’, ‘Aceite’, ‘Arroz’]

>>> details = [‘mineral natural’, ‘de oliva virgen’, ‘basmati’]
>>> for product, detail in zip(shopping, details):
... print(product, detail)
...
Agua mineral natural
Aceite de oliva virgen
Arroz basmati

Manejo de listas para matrices

Hasta el momento se ha trabajado la listas con datos numéricos simples, ahora se amplía
el concepto definiendo listas con elementos que a su vez son listas, esto permite dar el
manejo de una matriz.
Si se quiere trabajar el concepto de matriz en una lista, se recurre al concepto de que los
elementos de la lista son heterogéneos, en donde sus elementos pueden ser también
listas:
Entonces una matriz es una lista donde sus elementos van a ser listas con igual cantidad
de datos.
Ejemplo de una matriz con datos numéricos
m2=[[5,3,8],[5,2,4]]
En este ejemplo m2 es una lista que contiene en sus elementos dos listas
Esto indica que la cantidad de listas es el número de filas y la cantidad de elementos de
las listas, es el número de columnas
El acceso a un elemento específico se lo realiza con dos índices, un índice para ubicar un
elemento dentro de la lista general y otro índice para ubicar un dato dentro de la lista
interna.
Entonces si se quiere acceder a dato 8 se lo realiza así:
m2[0][2]
con m2[0] se accede a la lista [5,3,8] para acceder a un dato de esta lista se utiliza otros
[], para el 8 es el índice 2 entonces se obtiene m2[0][2]

En términos prácticos se tiene que la lista m2 representa una matriz de 2X3

5,3,8
5,2,4
Dos filas y tres columnas.

Con estos conceptos ya se puede trabajar con matrices dentro del lenguaje Python.
Definición de una matriz
matriz = [] #matriz vacía
matriz2=[[5,3,8],[5,2,4]] # matriz de 2 filas por 3 columnas

Definición de una matriz con ceros y con filas y columnas variantes.

#Definir una matriz con ceros forma 1

filas=int(input("Numero de filas"))
columnas=int(input('Numero de columnas'))

Matriz=[]

for i in range(filas):
Matriz.append([0]*columnas)

print(Matriz)

si el número de filas es 3 y el de columnas es 3, la matriz que se muestra es:

[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

#Definir una matriz con ceros forma 2

filas=int(input("Numero de filas"))
columnas=int(input('Numero de columnas'))

Matriz1=[]

for i in range(filas):
fila=[]
for j in range(columnas):
fila.append(0)
Matriz.append(fila)

print(Matriz)

Ejercicio. Definir una lista (matriz) donde las filas pares sean 0 y las filas impares sean 1
#filas pares 0 filas impares 1 forma 1
filas=int(input("Numero de filas"))
columnas=int(input('Numero de columnas'))

Matriz=[]

for i in range(filas):
if i%2==0:
Matriz.append([0]*columnas)
else:
Matriz.append([1]*columnas)

print(Matriz)

si el número de filas es 4 y el de columnas es 3, la matriz que se muestra es:

[[0, 0, 0], [1, 1, 1], [0, 0, 0], [1, 1, 1]]

Segunda solución
#filas pares 0 filas impares 1 forma 2
filas=int(input("Numero de filas"))
columnas=int(input('Numero de columnas'))

Matriz=[]

for i in range(filas):
fila=[]
if i%2==0:
for j in range(columnas):
fila.append(0)
else:
for j in range(columnas):
fila.append(1)
Matriz.append(fila)

print(Matriz)

Leer datos numéricos en una matriz desde el teclado.

#Definir una matriz

filas=int(input("Numero de filas"))
columnas=int(input('Numero de columnas'))

Matriz=[]

for i in range(filas):
fila=[]
for j in range(columnas):
fila.append(int(input(f'dato {i},{j} =')))
Matriz.append(fila)

print(Matriz)

Ejercicio.
Se tiene una matriz con datos numéricos, hallar el promedio de los números pares.

Pasos genéricos
Definir matriz
Leer matriz
Sumar y contar pares de la matriz
Calcular promedio pares e impares matriz

#Definir una matriz

filas=int(input("Numero de filas"))
columnas=int(input('Numero de columnas'))

mat=[]
# Leer matriz
for i in range(filas):
 fila=[]
for j in range(columnas):
fila.append(int(input(f'dato {i},{j} =')))
mat.append(fila)
#mostrar matriz
print(mat)
#sumar y contar pares de la matriz
sump=0
conp=0
for i in range(filas):
for j in range(columnas):
if mat[i][j]%2==0:
sump+=mat[i][j]
conp+=1
#hallar promedio pares
if conp>0:
prop=sump/conp
print('promedio de pares = ',prop)
else:
print('En la matriz no hay números pares')

Ejercicio.
Se tiene una matriz con datos numéricos, hallar el promedio de los números primos.

Ejercicio.
Se tiene una matriz con datos numéricos, hallar el promedio de los números pares.

5.1.8 Funciones matemáticas

Python nos ofrece, entre otras4, estas tres funciones matemáticas básicas que se
pueden aplicar sobre listas.
Estos métodos funcionan para listas con datos numéricos.

Suma de todos los valores: Mediante la función sum():

>>> data = [5, 3, 2, 8, 9, 1]
>>> sum(data)
28

Mínimo de todos los valores: Mediante la función min():

>>> data = [5, 3, 2, 8, 9, 1]
>>> min(data)
1

Máximo de todos los valores: Mediante la función max():

>>> data = [5, 3, 2, 8, 9, 1]
>>> max(data)
9
4
Ejercicios aplicados a matrices
Aplicando las anteriores funciones realizar los siguientes ejercicios

Hallar los mayores, los menores y la suma de datos de cada fila

Hallar el dato mayor de una matriz aplicando estas funciones
Hallar el dato menor de una matriz
Hallar el promedio de cada fila
Hallar el promedio de la matriz

Hallar los mayores, los menores y la suma de datos de cada fila

Pasos genéricos

Definir matriz
Leer matriz
Recorrer la matriz y por cada fila
Mostrar mayor de cada fila
Mostrar menor de cada fila
Mostrar suma de cada fila

#Definir una matriz

filas=int(input("Numero de filas -> "))

columnas=int(input('Numero de columnas -> '))

mat=[]
# Leer matriz
for i in range(filas):
fila=[]
for j in range(columnas):
fila.append(int(input(f'dato {i},{j} =')))
mat.append(fila)
#mostrar matriz
print('\n Matriz creada \n')
for i in range(filas):
print(mat[i])

for i in range(filas):
print('\nfila ',mat[i],'\n')
print('mayor fila = ',max(mat[i]))
print('menor fila = ',min(mat[i]))
print('suma fila = ',sum(mat[i]))

Hallar el dato mayor de una matriz

Pasos genéricos

Definir matriz
Leer matriz
Llenar lista con los mayores de cada fila
Obtener mayor de la lista resultante
Mostrar mayor

#Definir una matriz

filas=int(input("Numero de filas -> "))

columnas=int(input('Numero de columnas -> '))

mat=[]
# Leer matriz
for i in range(filas):
fila=[]
for j in range(columnas):
fila.append(int(input(f'dato {i},{j} =')))
mat.append(fila)
#mostrar matriz
print('\n Matriz creada \n')
for i in range(filas):
print(mat[i])

lmay=[] #define lista para los mayores de cada fila

for i in range(filas):
lmay.append(max(mat[i]))
mayor=max(lmay)
print('Dato mayor de la matriz ',mayor)

Hallar el dato menor de una matriz, con matriz creada en forma aleatoria

Pasos genéricos

Definir matriz
Llenar matriz aleatoriamente
Llenar lista con los menores de cada fila
Obtener menor de la lista resultante
Mostrar menor

#Definir una matriz

import random

filas=int(input("Numero de filas -> "))

columnas=int(input('Numero de columnas -> '))

mat=[]
# Leer matriz
for i in range(filas):
fila=[]
for j in range(columnas):
fila.append(random.randint(0,20)) #datos enteros aleatorios
mat.append(fila)
#mostrar matriz
print('\n Matriz creada \n')
for i in range(filas):
print(mat[i])

lmen=[] #define lista para los menores de cada fila

for i in range(filas):
lmen.append(min(mat[i])) # adiciona el menor de cada fila
menor=min(lmen)
print('Dato menor de la matriz ',menor)

MODULARIDAD

La modularidad es la característica de un sistema que permite que sea estudiado,

visto o entendido como la unión de varias partes que interactúan entre sí y que
trabajan solidariamente para alcanzar un objetivo común, realizando cada una de
ellas una tarea necesaria para la consecución de dicho objetivo.
Cada una de esas partes en que se encuentre dividido el sistema recibe el nombre
de módulo.
Idealmente un módulo debe poder cumplir las condiciones de caja negra, es decir,
ser independiente del resto de los módulos y comunicarse con ellos (con todos
o sólo con una parte) a través de entradas y salidas bien definidas.
FUNCIONES

El concepto de función es básico en prácticamente cualquier lenguaje de

programación. Se trata de una estructura que nos permite agrupar código.
Persigue dos objetivos claros:

1. No repetir trozos de código durante nuestro programa.

2. Reutilizar el código para distintas situaciones.

Una función es un miniprograma que tiene un conjunto de instrucciones lógicas y

realiza una tarea específica.

Una función viene definida por su nombre, sus parámetros y su valor de retorno.
Esta parametrización de las funciones las convierte en una poderosa herramienta
ajustable a las circunstancias que tengamos. Al invocarla se está solicitando su
ejecución para obtener unos resultados.
Independencia de las funciones
Las funciones se ejecutan en forma independiente. Este concepto es importante
tenerlo presente ya que mientras se esté ejecutando las instrucciones de la
función, no se conoce ninguna información de quién solicito su ejecución.
Al ser independiente se debe tener claro los canales de comunicación para que
una función realice la tarea específica y entregue los resultados al programa o
subprograma que lo invoca. Los canales de comunicación están determinados en
los parámetros y en el nombre mismo de la función, los cuales pueden ser
utilizados para enviar y recibir información a la función o de la función
respectivamente.

DEFINIR UNA FUNCION

Formato

def Nombre función ( lista de 0 o más parámetros ):

Cuerpo de la función identado
[ return expresión retorno]

def Palabra reservada para definir funciones

lista de 0 o más parámetros, Identificadores de los diferentes tipos de datos
separados con comas, encargadas de recibir y entregar valores y resultados
respectivamente.
Cuerpo de la función identado Conjunto de instrucciones lógicas que van a
realizar la tarea específica.
return expresión retorno Instrucción que puede ir dentro del cuerpo de acciones,
es opcional y permite retornar la información para lo cual fue llamada la función.
En Python el retorno es diferente a los demás lenguajes, pues permite retornar
varios elementos, lo cual exige tener bien claro, los diferentes elementos que
puede retornar.

Ejemplo

>>>def say_hello():
... print(‘Hello!’)

Invocar una función

Para invocar (o «llamar») a una función sólo tendremos que escribir su nombre
seguido de paréntesis. En el caso de la función sencilla (vista anteriormente) se
haría así:
>>> def say_hello():
... print(‘Hello!’)
...
>>> say_hello()
Hello!
Como era de esperar, al invocar a esta función se obtiene un mensaje por
pantalla, fruto de la ejecución del cuerpo de la función.

Retornar un valor
Las funciones pueden retornar (o «devolver») un valor.
Ejemplo:
>>> def uno():
... return 1
...
>>> uno()
1
>>> if uno() == 1:
... print(‘Siempre 1’)
... else:
... print(‘No se va a presentar’)
...

Siempre 1

Si una función no incluye un return de forma explícita, devolverá None de forma

implícita:

>>> def empty():

... x=0
...
>>> print(empty())
None

Parámetros y argumentos.

Los parámetros son un conjunto de identificadores que pueden representar los

diferentes tipos de datos manejados en Python.
Si una función no dispusiera de valores de entrada estaría muy limitada en su
actuación. Es por ello que los parámetros nos permiten variar los datos que
consume una función para obtener distintos resultados.
Funciones que reciben parámetros.

Obtener el mínimo de dos valores dados

>>> def _min(a, b):
... if a < b:
... return a
... else:
Return b
Parámetros por referencia
En otros lenguajes de programación existe el paso de parámetros por valor y por
referencia bien determinado. Si un parámetro es por valor, una función no puede
modificar el valor de las variables que recibe por fuera de su ejecución: un intento
por hacerlo simplemente altera las copias locales de dichas variables. Si el
parámetro es por referencia (dirección del parámetro), una función obtiene acceso
directo a las variables originales, permitiendo así su edición y reflejando el valor
planteado en la función, en el programa que la llamó.

En lenguaje C se tiene el ejemplo

1.
1. void CambiarCantidad(int *cantidad)
2. {
3. *cantidad = 5;
4. }
5.
6. int cantidad = 1;
7. CambiarCantidad(&cantidad);
8. printf("%d", cantidad); /* Imprime 5 */

En Python, en cambio, no se trabaja como otros lenguajes el concepto de paso

por valor/referencia, porque el lenguaje no trabaja con el concepto de variables
sino objetos y referencias.

En Python la asignación a = 1 no se dice que «a contiene el valor 1″ sino que

«a referencia a 1″. Por esto en Python los parámetros siempre se pasan por
referencia, pero la referencia es al valor, no a un campo de memoria que
almacena el valor.

El siguiente código no modifica los valores originales

def f(a, b, c):

# No altera los objetos originales.
a, b, c = 4, 5, 6 #Esta asignación es permitida en python

a, b, c = 1, 2, 3
f(a, b, c)
print(a, b, c) # Imprime 1, 2, 3.

No se modifican porque los números enteros son inmutables, de igual forma los de
coma flotante, las cadenas y otros objetos.

Lo inmutable es que una vez creado su valor, no puede ser modificado

¿Qué pasa con las siguientes acciones?

a=1

a=2

¿Cómo se entiende estas instrucciones?

La variable a no cambia de valor, se cambia la referencia de 1 a 2

No se cambia el valor del objeto, se le asigna una nueva referencia

La respuesta es que los números enteros (como también los de coma

flotante, las cadenas y otros objetos) son inmutables. Es decir, una vez
creados, su valor no puede ser modificado.

Las asignaciones

a=1

a=2

No está cambiando el valor de a de 1 a 2 sino quitando la referencia a 1 y

poniéndosela a 2. En términos más simples, no «cambias» el valor de un objeto
sino que le asigna una nueva referencia.

Las siguientes acciones demuestran con la función id() (id muestra la dirección de
un identificador) que la variable a no almacena valores, son referencias a un valor

id() es una función que entrega la dirección de memoria donde se va a encontrar

el valor

>>>a=1

>>> id(a) #muestra la dirección que referencia a 1

2952065149232

>>> a=2

>>> id(a) #muestra la dirección que referencia a 2

2952065149264

Las direcciones son diferentes por lo que a no almacena valores

Por lo tanto, en el código anterior, al ejecutar a, b, c = 4, 5, 6 se está creando

nuevas referencias para los números 4, 5 y 6 dentro de la función f con los
nombres a, b y c. Cuando la función termina y retorna al programa que lo llama, las
referencias de a, b y c son locales a la función, por lo que a,b y c en el programa
que lo llama corresponden a las referencias de los valores 1,2 y 3

Lo mismo ocurre con las string o cadenas que también son inmutables

>>>h='hola'

>>> id(h)

2952068065520

>>> h='pedro'

>>> id(h)

2952068065584

>>>

Con los objetos mutables como listas y diccionarios, no ocurre lo mismo.

Ejemplo.

def f(a):
a[0] = "CPython"
a[1] = "PyPy"
a.append("Stackless")

>>> items = ["Perro", "Gato"]

>>> f(items)
>>> items
['CPython', 'PyPy', 'Stackless']

Como ítems es una lista y es mutable, si es posible editarlo dentro de una función
y va a tener efecto por fuera de esta.

Se pueden utilizar objetos mutables para recibir el resultado de una tarea

específica, aspecto que se complementa en Python con el siguiente concepto.

Python permite en una función devolver o retornar varios objetos utilizando tuplas
o listas. Por ejemplo:

a=1
b=2
c=3

def f(a,b,c):
return 4, 5, 6
 a, b, c = f(a,b,c)
# Ahora "a" referencia a 4, "b" referencia a 5 y "c" referencia a 6.

En Python no es una buena práctica modificar los objetos pasados como

parámetros desde una función, puede llevar a resultados inesperados. No hay
razón para hacerlo, basta con retornar múltiples objetos.

Aplicación de estos conceptos dentro de los conceptos de listas, como vectores y

como matrices.

Funciones que permiten leer listas como vectores y como matrices

#Funcion que recibe un parámetro correspondiente a una lista, la modifica y #los

valores se van a reflejar en el programa que lo llama

def leerVector(l1):
cd=int(input('Cantidad de datos -> '))
for i in range(cd):
l1.append(int(input(f'dato {i} = ')))

#Funcion que recibe un parámetro correspondiente a una lista, la modifica y

#los valores se van a reflejar en el programa que lo llama

def leerMatriz(m1):
nf=int(input('Cantidad de filas -> '))
nc=int(input('Cantidad de columnas -> '))
for i in range(nf):
l1=[]
for j in range(nc):
l1.append(int(input(f'dato ({i},{j}) = ')))
m1.append(l1)

Las dos funciones anteriores utilizan los parámetros para recibir e resultado de las
funciones.

#Funcion que no recibe parámetros, crea una lista con valores y retorna la #lista

def leerVectorR():
l1=[]
cd=int(input('Cantidad de datos -> '))
for i in range(cd):
l1.append(int(input(f'dato {i} = ')))
return l1

#Funcion que no recibe parámetros, crea una lista para ser trabajado como
#vector llena valores y retorna la lista

def leerMatrizR():
m1=[]
nf=int(input('Cantidad de filas -> '))
nc=int(input('Cantidad de columnas -> '))
for i in range(nf):
l1=[]
for j in range(nc):
l1.append(int(input(f'dato ({i},{j}) = ')))
m1.append(l1)
return m1

#Programa que llama a cada una de las funciones definidas

l1=[]
leerVector(l1)
print('Lista leida \n',l1)

m1=[]
leerMatriz(m1)
print('Matriz leida \n',m1)

l1=leerVectorR()
print('Vector leido con retorno \n',l1)

m2=leerMatrizR()
print('Matriz con retorno leida \n',m2)

Ejercicio. Determinar si un valor dado es Fibonacci.

#determinar si un valor dado es primo

def fibonacci(valor):
a=0
b=1
t=0
while t<valor :
t=a+b
a=b
b=t
if t==valor:
return True
else:
return False
num=int(input('Valor numérico -> '))
if Fibonacci(num)==True:
print(f'{num} es numero fibonacci')
else:
print(f'{num} no es numero fibonacci')

Ejercicio. Determinar si un valor dado, es un número primo

#determinar si un valor dado es primo

def primo(valor):
b=0;
c=2
while c<valor and b==0:
if valor%c==0:
b=1
else:
c+=1
return b

num=int(input('Valor numérico -> '))

if primo(num)==0:
print(f'{num} es numero primo')
else:
print(f'{num} no es numero primo')

Aplicación de estos conceptos, dentro de los conceptos de listas como vectores y

como matrices.

Ejercicio.
Se tiene una matriz con datos numéricos, hallar le promedio de los números
primos de la matriz.

Pasos genéricos

leerMatriz
Hallar suma y cuenta de primos
Hallar el promedio
Mostrar promedio

Cada paso genérico es una función

Ahora dentro de cada paso genérico se pueden llamar a funciones

def leerMatriz():
m=[]
 nf=int(input('Cantidad de filas -> '))
nc=int(input('Cantidad de columnas -> '))
for i in range(nf):
l1=[]
for j in range(nc):
l1.append(int(input(f'dato ({i},{j}) = ')))
m.append(l1)
return m

def primo(valor):
c=1
cd=0
while c<=valor :
if valor%c==0:
cd+=1
c+=1
if cd==2:
return 1
else:
return 0

def sumaCuentaPrimosMatriz(m):
sump,conp=0,0
for i in range(len(m)):
for j in range(len(m[i])):
if primo(m[i][j])==1:
sump +=m[i][j]
conp +=1
return sump,conp

#programa principal
m=leerMatriz()
sum,con=sumaCuentaPrimosMatriz(m)
if con>0:
print ('promedio =',sum/con)
else:
print('no hay primos en la matriz')

Ejercicio.
Se tiene una matriz con datos numéricos, formar dos listas con primos y Fibonacci
respectivamente.

Pasos genéricos
Leer matriz
Obtener listas de primos y Fibonacci
Mostrar lista primos
Mostrar lista fibonacci

def leerMatriz():
m=[]
nf=int(input('Cantidad de filas -> '))
nc=int(input('Cantidad de columnas -> '))
for i in range(nf):
l1=[]
for j in range(nc):
l1.append(int(input(f'dato ({i},{j}) = ')))
m.append(l1)
return m

def primo(valor):
c=1
cd=0
while c<=valor :
if valor%c==0:
cd+=1
c+=1
if cd==2:
return 1
else:
return 0

def fibonacci(valor):
a=0
b=1
t=0
while t<valor :
t=a+b
a=b
b=t
if t==valor:
return True
else:
return False

def ListaPrimosFibonacci(m):
lp=[]
 lf=[]
sump,conp=0,0
for i in range(len(m)):
for j in range(len(m[i])):
if primo(m[i][j])==1:
lp.append(m[i][j])
if fibonacci(m[i][j])==True:
lf.append(m[i][j])
return lp,lf

#programa principal
m=leerMatriz()
lp,lf=ListaPrimosFibonacci(m)
print('Lista de primos \n',lp)
print('Lista de fibonacci \n ',lf)

Diseño de un programa

Para colocar varios ejercicios relacionados con vectores o con matrices, éstos
deben ejecutarse dentro de un mismo programa en forma organizada.

Una de las formas que permiten realizar varias acciones a la vez, es el manejo de
un menú en donde se hace un diseño de ejecución de un programa. El menú
permite integrar varias acciones en un programa, hace parte de lo que se
denomina el diseño de un programa.
El diseño es una etapa que sigue al análisis en donde se especifica el cómo se va
a ejecutar el programa.

Ejemplo

Se requiere hacer un programa que permita ejecutar varias acciones sobre un

vector, coordinadas con un menú. Las acciones son las siguientes:
Leer una lista, ordenarlo lista, sacar el mayor y el menor de la lista, obtener el
promedio de primos y el Fibonacci mayor, todas las acciones exigen primero que
se lea la lista. La lista se lee una sola vez.

La integración de todas las acciones se las realiza con un menú, como el

siguiente:

Menú de operaciones con lista

---------------------------------
1. Leer lista
2. Mostrar lista
 3. Ordenar lista
4. Mayor y menor lista
5. Promedio de primos de la lista
6. Fibonacci mayor de la lista

7. Salir
--------------------------------
Elija una opción (1-7): 4
Leer Opcion

Donde el usuario puede acceder a cualquier opción de las especificadas y al

hacerlo se pueda ver la ejecución de cada una de ellas, sin salirse del menú, el
cual se seguirá mostrando hasta que se digite la opción 7, que es la que indica
salir.

Para desarrollar un menú se combina acciones de repetición y selección, y para

que todo quede modularizado, cada opción se la realiza con una función.

Se puede trabajar el menú con ciclo mientras combinada con una instrucción
match-case

Sentencia match-case

Disponible a partir de la versión 3.10. Ésta se podría asemejar a la sentencia

«switch» que ya existe en otros lenguajes de programación.

Ejemplo

>>> command = 'Hello, World!'

>>> match command:
... case 'Hello, World!':
... print('Hello to you too!')
... case 'Goodbye, World!':
... print('See you later')
... case other:
... print('No match found')

Hello to you too!

Lo que hace realmente la instrucción match – case es hacer una serie de

condicionales if elif anidados como muestra el siguiente ejemplo.

Ejercicio con instrucciones if elif para coordinar el menú.

def leerLista():
lista=[]
cd=int(input('Cantidad de datos lista'))
for i in range(cd):
 lista.append(int(input(f'dato ({i}) --> ')))
return lista

def mostrarLista(l1):
for i in range(len(l1)):
print(f'dato ({i})--> {l1[i]}')

def ordenarLista(l1):
l1.sort()
print('ordenada ascendente ')
mostrarLista(l1)
l1.sort(reverse=True)
print('ordenada descendentemente ')
mostrarLista(l1)

while True:
print ('Menu Lista')
print('------------------------------')
print('1. Leer lista ')
print('2. Mostrar lista ')
print('3. Ordenar lista ')
print('4. Mayor y menor lista ')
print('5. Promedio primos lista ')
print('6. Fibonacci mayor lista ')
print('7. Salir ')
print('------------------------------ ')

opcion=int(input('Opcion --> '))

if opcion==1:
l1=leerLista()
elif opcion==2:
mostrarLista(l1)
elif opcion==3:
ordenarLista(l1)
elif opcion==7:
break

Manejo de cadenas – string

Longitud de una cadena

Para obtener la longitud de una cadena podemos hacer uso de len(), una función
común a prácticamente todos los tipos y estructuras de datos en Python:
>>> proberb = ‘Lo cortés no quita lo valiente’
>>> len(proverb)
27
>>> empty = ‘’
>>> len(empty)
0

Pertenencia de un elemento
Para determinar si una subcadena se encuentra en una cadena de texto se utiliza
el operador in para ello. Se trata de una expresión que tiene como resultado un
valor «booleano» verdadero o falso:
>>> proverb = ‘Más vale malo conocido que bueno por conocer’
>>> ‘malo’ in proverb
True
>>> ‘bueno’ in proverb
True
>>> ‘regular’ in proverb
False

Habría que prestar atención al caso en el que intentamos descubrir si una

subcadena no está en la cadena de texto:
>>> dna_sequence = ‘ATGAAATTGAAATGGGA’
>>> not(‘C’ in dna_sequence) # Primera aproximación
True
>>> ‘C’ not in dna_sequence # Forma pitónica
True

Dividir una cadena por separador función split()

Para dividir un texto por algún tipo de separador , se utiliza la función split()
>>> proverb = ‘No hay mal que por bien no venga’
>>> proverb.split()

[‘No’, ‘hay’, ‘mal’, ‘que’, ‘por’, ‘bien’, ‘no’, ‘venga’]

>>> tools = ‘Martillo,Sierra,Destornillador’
>>> tools.split(‘,’)
[‘Martillo’, ‘Sierra’, ‘Destornillador’]

Nota: Si no se especifica un separador, split() usa por defecto cualquier secuencia

de espacios en blanco, tabuladores y saltos de línea.

La funcion split() devuelve una lista , donde cada elemento es una parte de la
cadena de texto original:
>>> game = ‘piedra-papel-tijera’
>>> type(game.split(‘-‘))
List

Ejercicio
Sabiendo que la longitud de una lista se calcula igual que la longitud de una
cadena de texto,
obtenga el número de palabras que contiene la siguiente cadena de texto:

quote = ‘Before software can be reusable, it first has to be usable’

Limpiar cadenas función strip()

La función strip() se utiliza para eliminar caracteres del principio y del final de un
«string» generalmente conocidos como caracteres de relleno.
las variantes de esta función permiten aplicarla únicamente al comienzo o
únicamente al final de la cadena de texto.
Ejemplo. Eliminar caracteres de relleno:

>>> serial_number = ‘\n\t \n 48374983274832 \n\n\t \t \n’

>>> serial_number.strip()
‘48374983274832’

Nota: Si no se especifican los caracteres a eliminar, strip() usa por defecto

cualquier combinación de espacios en blanco, saltos de línea \n y tabuladores \t.

«limpieza» por la izquierda (comienzo) y por la derecha (final)

Limpieza por la izquierda lstrip()

>>> serial_number.lstrip()
‘48374983274832 \n\n\t \t \n’

Limpieza por la derecha

>>> serial_number.rstrip()
􀀉\n\t \n 48374983274832’
Como habíamos comentado, también existe la posibilidad de especificar los
caracteres que
queremos borrar:
>>> serial_number.strip(\n’)

Importante: La función strip() no modifica la cadena que estamos usando (algo

obvio porque los «strings» son inmutables) sino que devuelve una nueva cadena
de texto con las modificaciones pertinentes.
Realizar búsquedas
Aunque hemos visto que la forma pitónica de saber si una subcadena se
encuentra dentro de otra es a través del operador in, Python ofrece distintas
alternativas para realizar búsquedas en cadenas de texto.
Vamos a partir de una variable que contiene un trozo de la canción Mediterráneo
de Joan
Manuel Serrat para ejemplificar las distintas opciones que tenemos:
>>> lyrics = ‘’’Quizás porque mi niñez
... Sigue jugando en tu playa
... Y escondido tras las cañas
... Duerme mi primer amor
... Llevo tu luz y tu olor
... Por dondequiera que vaya’’’
Comprobar si una cadena de texto empieza o termina por alguna subcadena:
>>> lyrics.startswith(‘Quizás’)
True
>>> lyrics.endswith(‘Final’)
False
Encontrar la primera ocurrencia de alguna subcadena:
>>> lyrics.find(‘amor’)
93
>>> lyrics.index(‘amor’)
93
Tanto find() como index() devuelven el índice de la primera ocurrencia de la
subcadena que estemos buscando, pero se diferencian en su comportamiento
cuando la subcadena buscada no existe:
>>> lyrics.find(‘universo’)
-1
>>> lyrics.index(‘universo’)

Contabilizar el número de veces que aparece una subcadena:

>>> lyrics.count(‘mi’)
2
>>> lyrics.count(‘tu’)
3
>>> lyrics.count(‘él’)
0

Ejercicio
Dada la siguiente letra5, obtenga la misma pero sustituyendo la palabra voices por
sounds:
>>> song = ‘’’You look so beautiful in this light
... Your silhouette over me
... The way it brings out the blue in your eyes
... Is the Tenerife sea
... And all of the voices surrounding us here
... They just fade out when you take a breath
... Just say the word and I will disappear
... Into the wilderness’’’

Utilice para ello únicamente búsqueda, concatenación y troceado de cadenas de

texto.
Reemplazar elementos

Podemos usar la función replace() indicando la subcadena a reemplazar, la

subcadena de reemplazo y cuántas instancias se deben reemplazar. Si no se
especifica este último argumento, la sustitución se hará en todas las instancias
encontradas:
>>> proverb = ‘Quien mal anda mal acaba’
>>> proverb.replace(‘mal’, ‘bien’)
‘Quien bien anda bien acaba’
>>> proverb.replace(‘mal’, ‘bien’, 1) # sólo 1 reemplazo
‘Quien bien anda mal acaba’

Python nos permite realizar variaciones en los caracteres de una cadena de texto
para pasarlos a mayúsculas y/o minúsculas. Veamos las distintas opciones
disponibles:
>>> proverb = ‘quien a buen árbol se arrima Buena Sombra le cobija’
>>> proverb
‘quien a buen árbol se arrima Buena Sombra le cobija’
>>> proverb.capitalize()
‘Quien a buen árbol se arrima buena sombra le cobija’
>>> proverb.title()
‘Quien A Buen Árbol Se Arrima Buena Sombra Le Cobija’
>>> proverb.upper()
‘QUIEN A BUEN ÁRBOL SE ARRIMA BUENA SOMBRA LE COBIJA’
>>> proverb.lower()
‘quien a buen árbol se arrima buena sombra le cobija’

Identificando caracteres
Funciones para identificar qué tipo de caracteres contiene.
funciones:
Detectar si todos los caracteres son letras o
números
>>> ‘R2D2’.isalnum()
True
>>> ‘C3-PO’.isalnum()
False

Detectar si todos los caracteres son números

>>> ‘314’.isnumeric()
True
>>> ‘3.14’.isnumeric()
False
Detectar si todos los caracteres son letras
>>> ‘abc’.isalpha()
True
>>> ‘a-b-c’.isalpha()
False

Detectar mayúsculas/minúsculas
>>> ‘BIG’.isupper()
True
>>> ‘small’.islower()
True
>>> ‘First Heading’.istitle()
True

Interpolación de cadenas
interpolar valores dentro de cadenas de texto utilizando diferentes formatos.
Interpolar (en este contexto) significa sustituir una variable por su valor dentro de
una cadena de texto.
Veamos los estilos que proporciona Python para este cometido:
Nombre Símbolo Soportado
Los f-strings aparecieron en Python 3.6 y se suelen usar en código de nueva
creación. Es la forma más potente – y en muchas ocasiones más eficiente – de
formar cadenas de texto incluyendo valores de otras variables.
La interpolación en cadenas de texto es un concepto que existe en la gran
mayoría de lenguajes de programación y hace referencia al hecho de sustituir los
nombres de variables por sus valores cuando se construye un «string».
Para indicar en Python que una cadena es un «f-string» basta con precederla de
una f e incluir las variables o expresiones a interpolar entre llaves {...}.
Supongamos que disponemos de los datos de una persona y queremos formar
una frase de
bienvenida con ellos:
>>> name = ‘Elon Musk’
>>> age = 49
>>> fortune = 43_300
>>> f’Me llamo {name}, tengo {age} años y una fortuna de {fortune} millones’
‘Me llamo Elon Musk, tengo 49 años y una fortuna de 43300 millones’

Advertencia: Si olvidamos poner la f delante del «string» no conseguiremos

sustitución de variables.
Incluir llaves dentro del texto
La respuesta esduplicar las llaves:
>>> x = 10
>>> f’The variable is {{ x = {x} }}’
‘The variable is { x = 10 }’

Formateando cadenas
Nivel intermedio
Los «f-strings» proporcionan una gran variedad de opciones de formateado:
ancho del texto, número de decimales, tamaño de la cifra, alineación, etc.
Dando formato a valores enteros:

>>> mount_height = 3718

>>> f’{mount_height:10d}’
‘ 3718’
>>> f’{mount_height:010d}’
‘0000003718’

Dando formato a otras bases:

>>> value = 0b10010011
>>> f’{value}’
‘147’
>>> f’{value:b}’
‘10010011’
>>> value = 0o47622
>>> f’{value}’
‘20370’
>>> f’{value:o}’
‘47622’
>>> value = 0xab217
>>> f’{value}’
‘700951’
>>> f’{value:x}’
‘ab217’

Dando formato a valores flotantes:

>>> pi = 3.14159265
>>> f’{pi:f}’ # 6 decimales por defecto (se rellenan con ceros si procede)
‘3.141593’
>>> f’{pi:.3f}’
‘3.142’
>>> f’{pi:12f}’
‘ 3.141593’
>>> f’{pi:7.2f}’
‘ 3.14’
>>> f’{pi:07.2f}’
‘0003.14’
>>> f’{pi:.010f}’
‘3.1415926500’
>>> f’{pi:e}’
‘3.141593e+00’

Alineando valores:
>>> text1 = ‘how’
>>> text2 = ‘are’
>>> text3 = ‘you’
>>> f’{text1:<7s}|{text2:^11s}|{text3:>7s}’
‘how | are | you’
>>> f’{text1:-<7s}|{text2:·^11s}|{text3:->7s}’
‘how----|····are····|----you’

Modo «debug»
A partir de Python 3.8, los «f-strings» permiten imprimir el nombre de la variable y
su valor, como un atajo para depurar nuestro código. Para ello sólo tenemos que
incluir un símbolo = después del nombre de la variable:
>>> serie = ‘The Simpsons’
>>> f’{serie=}’
"serie=’The Simpsons"
>>> imdb_rating = 8.7
>>> num_seasons = 30
>>> f’{imdb_rating=}’
‘imdb_rating=8.7’
>>> f’{serie[4:]=}’ # incluso podemos añadir expresiones!
"serie[4:]=’Simpsons’"
>>> f’{imdb_rating / num_seasons=}’
‘imdb_rating / num_seasons=0.29’

Ejercicios.
Realizar con un menú las siguientes ejercicios
Se tiene una cadena, determinar lo siguiente:
Las veces que aparece un carácter en la cadena
Reemplazar un carácter dado en la cadena
Determinar cual es el carácter que más se repite
Ordenar una cadena

Solución
Las veces que aparece un carácter en una cadena

Determinar cadena
Leer carácter
Contar carácter
Mostrar contador

cadena=input('Digitar cadena -> ')

caracter=input('Digitar caracter a leer -> ')
c=cadena.count(caracter)
print(f'caracter {caracter} aparece {c} veces')

Reemplazar un carácter dado en la cadena

Leer cadena
Leer carácter a reemplazar
Leer carácter de reemplazo
Reemplazar Carácter
Mostrar cadena

cadena=input('Digitar cadena -> ')

caracter=input('Digitar caracter a reemplazar -> ')
caracterrem=input('Digitar caracter de reemplazo -> ')
cad1=cadena.replace(caracter,caracterrem)
print('Cadena resultante -> ',cad1)

Determinar los caracteres y las veces que se repiten

Leer cadena
Recorrer cadena
Por cada carácter determinar si ya se contó
Si no se ha contado contarlo
Almacenar carácter en lista de contados y el contador en contados
Recorrer lista de contados y mostrar contados con su contador correspondiente
cad=input('Cadena para determinar caracter más repetido')
cnr=[]
con=[]
for i in range(len(cad)):
b=cad[i] in cnr
if b==False:
cnr.append(cad[i])
con.append(cad.count(cad[i]))
for i in range(len(cnr)):
print('Dato -> ',cnr[i], ' veces que se repite ->',con[i])

Determinar cual es el carácter que más se repite

Leer cadena
Recorrer cadena
Por cada carácter contarlo si no se ha contado
Almacenar carácter en lista cnr y el contador en contados
Obtener el contador mayor de cont y el índice
Mostrar contador mayor con el índice correspondiente

cad=input('Cadena para determinar carácter más repetido')

cnr=[]
con=[]
for i in range(len(cad)):
b=cad[i] in cnr
if b==False:
cnr.append(cad[i])
con.append(cad.count(cad[i]))
max=max(con)
indice=con.index(max)
print('dato que más se repite -> ',cnr[indice], ' veces ',max)

Ordenar una cadena

Leer cadena
Formar una lista con la cadena
Ordenar lista
Formar una cadena con la lista
Mostrar lista

cad=input('Cadena a ordenar -> ')

l1=list(cad)
l1.sort()
print('lista ordenada\n',l1)
cadena=''
for i in range(len(l1)):
cadena=cadena+l1[i]
print('cadena ordenada -> ',cadena)

Tuplas

El concepto de tupla es muy similar al de lista. Aunque hay algunas diferencias

menores, lo fundamental es que, mientras una lista es mutable y se puede
modificar, una tupla no admite cambios y por lo tanto, es inmutable.1

Creación de tuplas

Podemos pensar en crear tuplas tal y como lo hacíamos con listas, pero usando
paréntesis
en lugar de corchetes:

>>> empty_tuple = ()
>>> tenerife_geoloc = (28.46824, -16.25462)
>>> three_wise_men = (‘Melchor’, ‘Gaspar’, ‘Baltasar’)

Tuplas de un elemento
Creación de tupla de un único elemento.
La intención primera sería hacerlo de la siguiente manera:

>>> one_item_tuple = (‘Papá Noel’)

>>> one_item_tuple
‘Papá Noel’
>>> type(one_item_tuple)
str

De esta forma se crea una variable de tipo str (cadena de texto).

Para crear una tupla de un elemento se debe añadir una coma al final:

>>> one_item_tuple = (‘Papá Noel’,)

>>> one_item_tuple
(‘Papá Noel’,)

>>> type(one_item_tuple)
tuple

Tuplas sin paréntesis

En algunos casos las tuplas no llevan paréntesis.

ejemplos:
>>> one_item_tuple = ‘Papá Noel’,
>>> three_wise_men = ‘Melchor’, ‘Gaspar’, ‘Baltasar’
>>> tenerife_geoloc = 28.46824, -16.25462

Modificar una tupla

Como ya hemos comentado previamente, las tuplas son estructuras de datos
inmutables.
Una vez que las creamos con un valor, no podemos modificarlas. Veamos qué
ocurre si lo intentamos:
>>> three_wise_men = ‘Melchor’, ‘Gaspar’, ‘Baltasar’
>>> three_wise_men[0] = ‘Tom Hanks’

Traceback (most recent call last):

File "<stdin>", line 1, in <module>
TypeError: ‘tuple’ object does not support item assignment

Conversión
Para convertir otros tipos de datos en una tupla podemos usar la función tuple():
>>> shopping = [‘Agua’, ‘Aceite’, ‘Arroz’]
>>> tuple(shopping)
(‘Agua’, ‘Aceite’, ‘Arroz’)
Esta conversión es válida para aquellos tipos de datos que sean iterables:
cadenas de caracteres, listas, diccionarios, conjuntos, etc. Un ejemplo que no
funciona es intentar convertir un número en una tupla:

>>> tuple(5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: ‘int’ object is not iterable

El uso de la función tuple() sin argumentos equivale a crear una tupla vacía:
>>> tuple()
()
Truco: Para crear una tupla vacía, se suele recomendar el uso de () frente a
tuple().

Operaciones con tuplas

Con las tuplas podemos realizar todas las operaciones que se realizan con listas
salvo las que conlleven una modificación «in-situ», es decir, las siguientes
instrucciones no se pueden realizar:

• reverse()
• append()
• extend()
• remove()
• clear()
• sort()

Desempaquetado de tuplas

El desempaquetado es una característica de las tuplas que permite asignar una

tupla a variables independientes:

>> three_wise_men = (‘Melchor’, ‘Gaspar’, ‘Baltasar’)

>>> king1, king2, king3 = three_wise_men
>>> king1
‘Melchor’
>>> king2
‘Gaspar’
>>> king3
‘Baltasar’

Python proporciona la función «built-in» divmod() que devuelve el cociente y el

resto de una división usando una única llamada. Lo interesante (para el caso que
nos ocupa) es que se suele utilizar el desempaquetado de tuplas para obtener los
valores:

>>> quotient, remainder = divmod(7, 3)

>>> quotient
2
>>> remainder
1

Intercambio de valores
A través del desempaquetado de tuplas se puede llevar a cabo el intercambio de
los valores de dos variables de manera directa:

>>> value1 = 40
>>> value2 = 20
>>> value1, value2 = value2, value1
>>> value1
20
>>> value2
40

Desempaquetado genérico

El desempaquetado de tuplas es extensible a cualquier tipo de datos que sea

iterable.
Ejemplos
.
Sobre cadenas de texto:
>>> oxygen = ‘O2’
>>> first, last = oxygen
>>> first, last
(‘O’, ‘2’)
>>> text = ‘Hello, World!’
>>> head, *body, tail = text
>>> head, body, tail
(‘H’, [‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘,‘, ‘ ‘, ‘W‘, ‘o‘, ‘r‘, ‘l‘, ‘d‘], ‘!‘)

Sobre listas:
>>> writer1, writer2, writer3 = [‘Virginia Woolf’, ‘Jane Austen’, ‘Mary Shelley’]
>>> writer1, writer2, writer3
(‘Virginia Woolf’, ‘Jane Austen’, ‘Mary Shelley’)

>>> text = ‘Hello, World!’

>>> word1, word2 = text.split()
>>> word1, word2
(‘Hello,’, ‘World!’)

Tuplas vs Listas

Aunque puedan parecer estructuras de datos muy similares, sabemos que las
tuplas carecen de ciertas operaciones, especialmente las que tienen que ver con
la modificación de sus valores, ya que no son inmutables.

4 potenciales ventajas del uso de tuplas frente a las listas:

1. Las tuplas ocupan menos espacio en memoria.

2. En las tuplas existe protección frente a cambios indeseados.
3. Las tuplas se pueden usar como claves de diccionarios (son «hashables»).
4. Las namedtuples son una alternativa sencilla a los objetos.

Diccionarios

Se traslada el concepto de diccionario de la vida real al de diccionario en Python.

Al fin y al cabo un diccionario es un objeto que contiene palabras, y cada palabra
tiene asociado un significado. Haciendo el paralelismo, en Python un diccionario
es también un objeto indexado por claves (las palabras) que tienen asociados
unos valores (los significados).

Los diccionarios en Python tienen las siguientes características:

• Mantienen el orden en el que se insertan las claves.

• Son mutables, con lo que admiten añadir, borrar y modificar sus elementos.
• Las claves deben ser únicas. A menudo se utilizan las cadenas de texto como
claves, pero en realidad podría ser cualquier tipo de datos inmutable: enteros,
flotantes, tuplas (entre otros).

• Tienen un acceso muy rápido a sus elementos, debido a la forma en la que

están implementados internamente.
Nota: En otros lenguajes de programación, a los diccionarios se les conoce como
arrays asociativos, «hashes» o «hashmaps».

Funcionalmente, un diccionario es similar a un mapa hash. Por lo tanto, no es

necesariamente una estructura de datos ordenada. Puede acceder al contenido de
un diccionario en cualquier orden arbitrario, siempre que conozca las claves.

Creación de diccionarios

Para crear un diccionario se usa llaves {} rodeando asignaciones clave: valor que
están separadas por comas. Veamos algunos ejemplos de diccionarios:

>>> empty_dict = {}

>>> rae = {
... ‘bifronte’: ‘De dos frentes o dos caras’,
... ‘anarcoide’: ‘Que tiende al desorden’,
... ‘montuvio’: ‘Campesino de la costa’
... }

>>> population_can = {
... 2015: 2_135_209,
... 2016: 2_154_924,
... 2017: 2_177_048,
... 2018: 2_206_901,
... 2019: 2_220_270
... }
En el código anterior se observa la creación de un diccionario vacío, otro donde
sus claves y sus valores son cadenas de texto y otro donde las claves y los
valores son valores enteros.

Conversión

Para convertir otros tipos de datos en un diccionario podemos usar la función

dict():

>>> # Diccionario a partir de una lista de cadenas de texto

>>> dict([‘a1’, ‘b2’])
{‘a’: ‘1’, ‘b’: ‘2’}

>>> # Diccionario a partir de una tupla de cadenas de texto

>>> dict((‘a1’, ‘b2’))

{‘a’: ‘1’, ‘b’: ‘2’}

>>> # Diccionario a partir de una lista de listas

>>> dict([[‘a’, 1], [‘b’, 2]])
{‘a’: 1, ‘b’: 2}
Nota: Cualquier iterable que tenga una estructura interna de 2 elementos
es susceptible de convertirse en un diccionario a través de la función dict().

Diccionario vacío
Existe una manera particular de usar dict() y es no pasarle ningún argumento.
diccionario vacío:
>>> dict()
{}

El uso de {} de más recomendable que dict(), no sólo por ser más pitónico sino por
tener (en promedio) un mejor rendimiento en tiempos de ejecución.

Creación con dict()

También es posible utilizar la función dict() para crear diccionarios y no tener que
utilizar llaves y comillas:
Supongamos que queremos transformar la siguiente información en un
diccionario:

Atributo Valor
name Guido
surname Van Rossum
job Python creator

Utilizando la construcción mediante dict podemos pasar clave y valor como

argumentos de la función:

>>> person = dict(

... name=’Guido’,
... surname=’Van Rossum’,
... job=’Python creator’
... )
>>> person
{‘name’: ‘Guido’, ‘surname’: ‘Van Rossum’, ‘job’: ‘Python creator’}

El inconveniente que tiene esta aproximación es que las claves deben ser
identificadores válidos en Python. Por ejemplo, no se permiten espacios:

>>> person = dict(

... name=’Guido van Rossum’,
... date of birth=’31/01/1956’

File "<stdin>", line 3

date of birth=􀀉31/01/1956􀀉
^
SyntaxError: invalid syntax
Operaciones con diccionarios
Obtener un elemento
Para obtener un elemento de un diccionario basta con escribir la clave entre
corchetes.

Ejemplo:

>>> rae = {
... ‘bifronte’: ‘De dos frentes o dos caras’,
... ‘anarcoide’: ‘Que tiende al desorden’,
... ‘montuvio’: ‘Campesino de la costa’
... }

>>> rae[‘anarcoide’]
‘Que tiende al desorden’

Si se accede con una clave que no existe, se obtiene un error:

>>> rae[‘acceso’]

Usando get()
Existe una función muy útil para «superar» los posibles errores de acceso por
claves inexistentes. Se trata de get() y su comportamiento es el siguiente:

1. Si la clave que buscamos existe, nos devuelve su valor.

2. Si la clave que buscamos no existe, nos devuelve None salvo que le indiquemos
otro valor por defecto, pero en ninguno de los dos casos obtendremos un error.

1 >>> rae
2 {‘bifronte’: ‘De dos frentes o dos caras’,
3’anarcoide’: ‘Que tiende al desorden’,

4 ‘montuvio’: ‘Campesino de la costa’}

5
6 >>> rae.get(‘bifronte’)
7 ‘De dos frentes o dos caras’
8
9 >>> rae.get(‘programación’)
10
11 >>> rae.get(‘programación’, ‘No disponible’)
12 ‘No disponible’

Línea 6: Equivalente a rae[‘bifronte’].

Línea 9: La clave buscada no existe y se obtiene None.5
Línea 11: La clave buscada no existe y nos devuelve el valor que hemos aportado
por defecto.
4 Nonees la palabra reservada en Python para la «nada».
5Realmente no estamos viendo nada en la consola de Python porque la representación
en cadena de texto es vacía.
Añadir o modificar un elemento
Para añadir un elemento a un diccionario sólo es necesario hacer referencia a la
clave y asignarle un valor:
• Si la clave ya existía en el diccionario, se reemplaza el valor existente por el
nuevo.
• Si la clave es nueva, se añade al diccionario con su valor.

Partimos del siguiente diccionario para ejemplificar estas acciones:

>>> rae = {
... ‘bifronte’: ‘De dos frentes o dos caras’,
...’anarcoide’: ‘Que tiende al desorden’,
... ‘montuvio’: ‘Campesino de la costa’
... }
Vamos a añadir la palabra enjuiciar a nuestro diccionario de la Real Academia de
la Lengua:
>>> rae[‘enjuiciar’] = ‘Someter una cuestión a examen, discusión y juicio'
>>> rae
{‘bifronte’: ‘De dos frentes o dos caras’,
’anarcoide’: ‘Que tiende al desorden’,
‘montuvio’: ‘Campesino de la costa’,
‘enjuiciar’: ‘Someter una cuestión a examen, discusión y juicio’}

Supongamos ahora que queremos modificar el significado de la palabra enjuiciar

por otra acepción:
>>> rae[‘enjuiciar’] = ‘Instruir, juzgar o sentenciar una causa’
>>> rae
{‘bifronte’: ‘De dos frentes o dos caras’,
’anarcoide’: ‘Que tiende al desorden’,
‘montuvio’: ‘Campesino de la costa’,
‘enjuiciar’: ‘Instruir, juzgar o sentenciar una causa’}

Creando desde vacío

Una forma muy habitual de trabajar con diccionarios es utilizar el patrón creación
partiendo de uno vacío e ir añadiendo elementos poco a poco.
Ejemplo: construir un diccionario donde las claves son las letras vocales y los
valores son sus posiciones:

>>> VOWELS = ‘aeiou’

>>> enum_vowels = {}
>>> for i, vowel in enumerate(VOWELS):
... enum_vowels[vowel] = i + 1
...
>>> enum_vowels
{‘a’: 1, ‘e’: 2, ‘i’: 3, ‘o’: 4, ‘u’: 5}
Nota: Utilización de la función enumerate() que se vió para las listas en el
apartado:
Iterar usando enumeración.
Ejercicio
Construya un diccionario partiendo de una cadena de texto con el siguiente
formato:
<city>:<population>;<city>:<population>;<city>:<population>;....

• Claves: ciudades.
• Valores: habitantes (como enteros).
Ejemplo
• Entrada: Tokyo:38_140_000;Delhi:26_454_000;Shanghai:24_484_000;
Mumbai:21_357_000;São Paulo:21_297_000
• Salida: {‘Tokyo’: 38140000, ‘Delhi’: 26454000, ‘Shanghai’: 24484000,
‘Mumbai’: 21357000, ‘São Paulo’: 21297000}

Pertenencia de una clave

La forma pitónica de comprobar la existencia de una clave dentro de un
diccionario, es utilizar el operador in:
>>> ‘bifronte’ in rae
True
>>> ‘almohada’ in rae
False
>>> ‘montuvio’ not in rae
False
Nota: El operador in siempre devuelve un valor booleano, es decir, verdadero o
falso.
Ejercicio
Usando un diccionario, cuente el número de veces que se repite cada letra en una
cadena de texto dada.

Ejemplo
• Entrada: ‘boom’
• Salida: {‘b’: 1, ‘o’: 2, ‘m’: 1}

Obtener todos los elementos

Python ofrece mecanismos para obtener todos los elementos de un diccionario. Se
parte del siguiente diccionario:
>>> rae
{‘bifronte’: ‘De dos frentes o dos caras’,
’anarcoide’: ‘Que tiende al desorden’,
‘montuvio’: ‘Campesino de la costa’,
‘enjuiciar’: ‘Instruir, juzgar o sentenciar una causa’}

Obtener todas las claves de un diccionario: Mediante la función keys():

>>> rae.keys()
dict_keys([‘bifronte’, ‘anarcoide’, ‘montuvio’, ‘enjuiciar’])

Obtener todos los valores de un diccionario: Mediante la función values():

>>> rae.values()
dict_values([
‘De dos frentes o dos caras’,
‘Que tiende al desorden’,
‘Campesino de la costa’,
‘Instruir, juzgar o sentenciar una causa’
])
Obtener todos los pares «clave-valor» de un diccionario: Mediante la función
items():
>>> rae.items()
dict_items([
(‘bifronte’: ‘De dos frentes o dos caras’),
(’anarcoide’: ‘Que tiende al desorden’),
(‘montuvio’: ‘Campesino de la costa’),
(‘enjuiciar’: ‘Instruir, juzgar o sentenciar una causa’)]

Nota: Para este último caso cabe destacar que los «items» se devuelven como
una lista de tuplas, donde cada tupla tiene dos elementos: el primero representa la
clave y el segundo representa el valor.

Longitud de un diccionario
Para conocer el número de elementos («clave-valor») que tiene un diccionario con
la función len():
>>> rae
{‘bifronte’: ‘De dos frentes o dos caras’,
’anarcoide’: ‘Que tiende al desorden’,
‘montuvio’: ‘Campesino de la costa’,
‘enjuiciar’: ‘Instruir, juzgar o sentenciar una causa’}
>>> len(rae)
4

Iterar sobre un diccionario

En base a los elementos que podemos obtener, Python proporciona tres maneras
de iterar sobre un diccionario.

Iterar sobre claves:

>>> for word in rae.keys():
... print(word)
...
bifronte
anarcoide
montuvio
enjuiciar

Iterar sobre valores:

>>> for meaning in rae.values():
... print(meaning)
...
De dos frentes o dos caras
Que tiende al desorden
Campesino de la costa
Instruir, juzgar o sentenciar una causa

Iterar sobre «clave-valor»:

>>> for word, meaning in rae.items():
... print(f’{word}: {meaning}’)
...
bifronte: De dos frentes o dos caras
anarcoide: Que tiende al desorden
montuvio: Campesino de la costa
enjuiciar: Instruir, juzgar o sentenciar una causa

Nota: En este último caso, recuerde el uso de los «f-strings» para formatear
cadenas de texto.

Diccionarios 163__

Ejercicio. Sumar números binarios con cadenas, no utilizando funciones de Python.

Ejercicio de aplicación

Ejercicio de aplicación.

Para un curso de la materia de Programación, de una cantidad dada de

estudiantes, se hizo el proceso de evaluación y se obtuvieron 3 calificaciones, con
los siguientes ponderados
Cal 1 30%
Cal 2 30%
Cal 3 40%

Si por cada estudiante se tiene la siguiente información

Codigo del Estudiante
Calificación 1
Calificación 2
Calificación 3

Realizar un algoritmo que permita encontrar la siguiente información.

Listado de los estudiantes con sus Calificaciones y el promedio final ordenado de

mayor a menor en el promedio.

Estudiantes con mayor calificación

Estudiantes con menor calificación

Promedio de calificaciones
Cantidad de estudiantes que aprobaron la materia
Cantidad de estudiantes que perdieron la materia
Analisis

Ejemplo

CE
8

Cod Est N1 N2 N3 Nf
0 1 3 3,5 4 3,5 = 3*,3+3,5*,3+4*,4
1 2 4 4,5 4,5 4,3
2 3 2,5 3,5 3 3
3 4 5 4 5 4,5
4 5 2,5 3 3 2,8
5 6 3 3 2 2,6
6 7 5 4 5 4,5
7 8 3 3 2 2,6

Ordenar

Cod Est N1 N2 N3 Nf
4 5 4 5 4,5
7 5 4 5 4,5
2 4 4,5 4,5 4,3
1 3 3,5 4 3,5
3 2,5 3,5 3 3
5 2,5 3 3 2,8
6 3 3 2 2,6
8 3 3 2 2,6

Mostrar lista

Promedio (SNf/CE)

Estudiantes con mayor calificación

Estudiantes con mayor calificación

Definir variables
Leer Datos de los estudiantes - listaEstudiantes listaCalificaciones
Calcular nota definitiva - listaDefinitiva
Ordenar definitiva y realizar cambios correspondientes – ordenaListaDefinitiva y
las demás listas
Obtener listado de notas- Mostrar todas las listas
Obtener estadísticas – Realizar estadísticas
Pasos genéricos
Leer estudiante y calificaciones
Calcular nota definitiva
Ordenar calificaciones
Mostrar listado general con calificación final
Realizar estadísticas

Realizar el ejercicio con solo listas sencillas

#Leer estudiante y calificaciones
Leer código lcod
Leer 3 calificaciones mcal

Calcular nota definitiva

Recorrer listas y llenar lfin

Ordenar calificaciones
Ordenar por lista lfin en orden descendente e intercambiar las listas
correspondientes

Mostrar listado general con calificación final

Recorrer las listas y mostrar código calificaciones y nota final

Realizar estadísticas
Estudiantes aprobados
Promedio de notas
Estudiantes con nota mayor
Estudiantes con nota menor

Funciones
leerCalificaciones
calcularDefinitiva
ordenarCalificaciones
mostrarListado
estadísticas

def leerCalificaciones(mcalif):
ce=int(input('Cantidad de estudiantes ->'))
lcod=[]

for i in range(ce):
print ('Informaci estudiante ',i+1)
lc=[]
lcod.append(int(input('Codigo estudiante-> ')))
lc.append(float(input('Calificacion 1 -> ')))
lc.append(float(input('Calificacion 2 -> ')))
lc.append(float(input('Calificacion 3 -> ')))
mcalif.append(lc)
 return lcod

def calcularDefinitiva(lc,mc):
ldef=[]
for i in range(len(lc)):
ldef.append(mc[i][0]*.30+mc[i][1]*.30+mc[i][2]*.40)
return ldef

def ordenarCalificaciones(lc,mc,lf):
for i in range(len(lc)):
for j in range(i,len(lc)):
if lf[j]>lf[i]:
aux=lf[i]
lf[i]=lf[j]
lf[j]=aux
# para mentener referencia se debe hacer intercambiar
la listas
# relacionadas mc y lc
laux=mc[i].copy()
mc[i]=mc[j].copy()
mc[j]=laux.copy()
aux=lc[i]
lc[i]=lc[j]
lc[j]=aux
def promedioCalificaciones(lf):
prom=sum(lf)/len(lf)
print('\npromedio calificaciones = ',prom)

def ganadosPerdidos(lf):
cg=0
cp=0
for i in range(len(lf)):
if lf[i]>3:
cg=cg+1
else:
cp=cp+1
print('Estudiantes que ganaron la materia ',cg)
print('Estudiantes que perdieron la materia = ',cp)

def estudiantesNotaMayorMenor(lc,lf):
mayor=max(lf)
menor=min(lf)
print('Estudiantes con nota mayor ',mayor)
for i in range(len(lc)):
if mayor==lf[i]:
 print('codigo -> ',lc[i])

print('\nEstudiantes con nota menor ',menor)

for i in range(len(lc)):
if menor==lf[i]:
print('codigo -> ',lc[i])

def mostrarCalificaciones(lc,mc,lf):
for i in range(len(lf)):
print(f'Codigo estudiante {lc[i]}')
print(f'n1 = {mc[i][0]}\n n2= {mc[i][1]}\n n3= {mc[i][2]}')
print('calificacion final -> ',lf[i])
mcal=[]
lcod=leerCalificaciones(mcal)
print(lcod)
print(mcal)
lfin=calcularDefinitiva(lcod,mcal)
ordenarCalificaciones(lcod,mcal,lfin)
mostrarCalificaciones(lcod,mcal,lfin)
promedioCalificaciones(lfin)
ganadosPerdidos(lfin)
estudiantesNotaMayorMenor(lcod,lfin)

Manejo de Excepciones - Errores

Al programar en Python algunas veces se pueden anticipar errores de ejecución, incluso

en un programa sintáctica y lógicamente correcto, pueden llegar a haber errores causados
por entrada de datos inválidos o inconsistencias predecibles.

En Python, puedes usar los bloques try y except para manejar estos errores
como excepciones.

Sintaxis de Try y Except en Python

Sintaxis de las declaraciones try y except en Python. La sintaxis básica es la siguiente:
try:
# Código a ejecutar
# Pero podría haber errores en este bloque
# En este bloque se coloca el código normal

except <tipo de error>:

# Este código se habilita cuando se presenta el error
 # En este bloque se pueden introducir acciones correctivas
else:
# Esto se ejecutará si el bloque try se ejecuta sin errores

finally:
# Este bloque se ejecutará siempre

Veamos el uso de cada uno de estos bloques:

 EL bloque try es el bloque con las sentencias que se quiere ejecutar. Sin embargo,
podrían llegar a haber errores de ejecución y el bloque se dejará de ejecutarse.
 El bloque except se ejecutará cuando el bloque try falle debido a un error. Este
bloque contiene sentencias que generalmente nos dan un contexto de lo que salió
mal en el bloque try.
 Siempre se debe especificar el tipo de error que se espera, como una excepción
dentro del bloque except dentro de <tipo de error> como lo muestra el ejemplo:
except ValueError:
print(‘Error: Entrada de valor inválida’

except ZeroDivisionError:
print(‘Error: Se presenta una división por cero ‘)

 Se puede usar except sin especificar el <tipo de error>. Pero no es una práctica
recomendable, ya que no se estará al tanto de los tipos de errores que puedan
ocurrir.

Cuando se ejecute el código dentro del bloque try, existe la posibilidad de que ocurran
diferentes errores.
Por ejemplo, se podría acceder a una lista utilizando un índice fuera de rango, usar una
clave incorrecta en un diccionario y tratar de abrir un archivo que no existe - todo esto
dentro de un bloque try.
En este caso, se podría esperar lo siguiente: IndexError, KeyError y FileNotFoundError. Y
se tendría que añadir un bloque except por cada tipo de error que se pueda anticipar.
 El bloque else se ejecutará solo si el bloque try se ejecuta sin errores. Esto puede
ser útil cuando se quiera continuar el código del bloque try. Por ejemplo, si se abre
un archivo en el bloque try, se podría leer su contenido dentro del bloque else.
  El bloque finally siempre es ejecutado sin importar que pase en los otros bloques,
esto puede ser útil cuando se quiera liberar recursos después de la ejecución de
un bloque de código, ( try, except o else ).

Nota: Los bloques else y finally son opcionales. En muchos casos puedes solo ocupar el
bloque try para tratar de ejecutar algo y capturar los errores como excepciones en el
bloque except.

Ejemplo.
Generalmente en la entrada de datos se puede presentar errores, en el aplicativo de las
calificaciones, si en la entrada de cantidad de estudiantes se digita un valor diferente a
entero, se va a presentar un error, en tal caso el programa cancela y muestra un mensaje
donde la excepción que se presenta es:

ValueError

Para evitar la cancelación del programa se debe capturar la excepción con el bloque
except y darle un tratamiento

Para evitar este error de entrada de enteros y reales se tiene las siguientes funciones

leerInt() y leerReal() donde cada una de ellas va a capturar la excepción y le va a dar un

tratamiento.
El tratamiento que se la da es permanecer leyendo el dato hasta que digite un valor
correcto, cuando esto ocurre se retorna este valor.
Funciones:

def leerInt(cadena):
while True:
try:
dato=int(input(cadena))
return dato
except ValueError:
print('Error de sintaxis: Digitar valor entero')

def leerFloat(cadena):
while True:
try:
dato=float(input(cadena))
return dato
except ValueError:
print('Error de sintaxis: Digitar valor real')

Con estas dos funciones el programa ya no va a cancelar y queda de la siguiente forma:

def leerInt(cadena):
 while True:
try:
dato=int(input(cadena))
return dato
except ValueError:
print('Error de sintaxis: Digitar valor entero')

def leerFloat(cadena):
while True:
try:
dato=float(input(cadena))
return dato
except ValueError:
print('Error de sintaxis: Digitar valor real')

def leerCalificaciones(mcalif):
# ce=int(input('Cantidad de estudiantes ->'))
ce=leerInt('Cantidad de esuudiantes -> ')
lcod=[]

for i in range(ce):
print ('Información estudiante ',i+1)
lc=[]
lcod.append(leerInt('Codigo estudiante-> '))
lc.append(leerFloat('Calificacion 1 -> '))
lc.append(leerFloat('Calificacion 2 -> '))
lc.append(leerFloat('Calificacion 3 -> '))
mcalif.append(lc)
return lcod

def calcularDefinitiva(lc,mc):
ldef=[]
for i in range(len(lc)):
ldef.append(mc[i][0]*.30+mc[i][1]*.30+mc[i][2]*.40)
return ldef

def ordenarCalificaciones(lc,mc,lf):
for i in range(len(lc)):
for j in range(i,len(lc)):
if lf[j]>lf[i]:
aux=lf[i]
lf[i]=lf[j]
lf[j]=aux
 # para mentener referencia se debe hacer intercambiar
la listas
# relacionadas mc y lc
laux=mc[i].copy()
mc[i]=mc[j].copy()
mc[j]=laux.copy()
aux=lc[i]
lc[i]=lc[j]
lc[j]=aux

def promedioCalificaciones(lf):
prom=sum(lf)/len(lf)
print('\npromedio calificaciones = ',prom)

def ganadosPerdidos(lf):
cg=0
cp=0
for i in range(len(lf)):
if lf[i]>3:
cg=cg+1
else:
cp=cp+1
print('Estudiantes que ganaron la materia ',cg)
print('Estudiantes que perdieron la materia = ',cp)

def estudiantesNotaMayorMenor(lc,lf):
mayor=max(lf)
menor=min(lf)
print('Estudiantes con nota mayor ',mayor)
for i in range(len(lc)):
if mayor==lf[i]:
print('codigo -> ',lc[i])

print('\nEstudiantes con nota menor ',menor)

for i in range(len(lc)):
if menor==lf[i]:
print('codigo -> ',lc[i])

def mostrarCalificaciones(lc,mc,lf):
for i in range(len(lf)):
print(f'Codigo estudiante {lc[i]}')
print(f'n1 = {mc[i][0]}\n n2= {mc[i][1]}\n n3= {mc[i][2]}')
print('calificacion final -> ',lf[i])

#programa principal
mcal=[]
lcod=leerCalificaciones(mcal)
print(lcod)
print(mcal)
lfin=calcularDefinitiva(lcod,mcal)
ordenarCalificaciones(lcod,mcal,lfin)
mostrarCalificaciones(lcod,mcal,lfin)
promedioCalificaciones(lfin)
ganadosPerdidos(lfin)
estudiantesNotaMayorMenor(lcod,lfin)

Ejercicio.
Con las calificaciones finales y el código del estudiante formar un
diccionario, en donde la clave sea el código del estudiante y el
valor la calificación final.

Una vez obtenida las calificaciones finales se puede formar dos

diccionarios

Diccionario uno con el código del estudiante como clave y la nota

final como valor.
Diccionario dos con el código del estudiante como clave y las
calificaciones como valor.

La siguiente función va a realizar los dos diccionarios

def formarDiccionarios(lc,mc,lf):
dic1={}
dic2={}
for i in range(len(lc)):
dic1[lc[i]]=lf[i]
dic2[lc[i]]=mc[i]
print('Diccionario 1\n',dic1)
print('Diccionario 2\n',dic2)
return dic1,dic2

Diccionario 1
{4: 4.0, 22: 2.0, 77: 2.0, 55: 1.0}

Diccionario 2
{4: [4.0, 4.0, 4.0], 22: [2.0, 2.0, 2.0], 77: [2.0, 2.0, 2.0], 55: [1.0, 1.0, 1.0]}
Ordenar diccionario por clave

Para ordenar por clave se tienen los siguientes pasos genéricos

Se hace uso de la función keys() para obtener la lista de claves del diccionario
Se ordena en orden ascendente o descendente
Se crea un nuevo diccionario vacío
Se recorre las claves de diccionario ordenado
Por cada iteración de la clave ordenada se va adicionando información al
diccionario
Mostrar diccionario

def ordenarDiccionarios(dic1,dic2):
codigos_ord=sorted(dic1.keys())
dic_ordenado1={}
dic_ordenado2={}
for key in codigos_ord:
dic_ordenado1[key]=dic1[key]
dic_ordenado2[key]=dic2[key]

print('Diccionario1 ordenado por clave \n',dic_ordenado1)

print('Diccionario2 ordenado por clave \n',dic_ordenado2)

Diccionario1 ordenado por clave

{11: 2.0, 22: 5.0, 33: 5.0, 66: 4.0, 99: 2.0}
Diccionario2 ordenado por clave
{11: [2.0, 2.0, 2.0], 22: [5.0, 5.0, 5.0], 33: [5.0, 5.0, 5.0], 66: [4.0, 4.0, 4.0], 99: [2.0, 2.0,
2.0]}

def ordenarDiccionarioValor(dic1):
dic_ordenado = dict(sorted(dic1.items(),key=lambda item:item[1]))
print(dic_ordenado)

Diccionario1 ordenado por Valor

{11: 2.0, 99: 2.0, 66: 4.0, 33: 5.0, 22: 5.0}

Las funciones Lambda son funciones anónimas que solo pueden contener una
expresión.

La sintaxis de una función lambda es

lambda args: expresión

Primero escribes la palabra clave lambda, se deja un espacio, después los argumentos
que se necesite separados por coma, dos puntos :, y por último la expresión que será el
cuerpo de la función.
Para el ordenamiento del diccionario por valor se hace uso de la función que saca los
ítems del diccionario, la cual entrega una lista con tuplas con dos elementos, ítems
representa estos dos elementos de los cuales se establece que se va a tomar como clave
de ordenamiento (key) el segundo campo.
Este procedimiento generaliza el ordenamiento por valor de un diccionario que tenga un
solo elemento en el valor.
Este ordenamiento no se lo podría realizar con el diccionario que tiene las calificaciones.

Mas sobre diccionarios

Combinar diccionarios
Dados dos (o más) diccionarios, es posible «mezclarlos» para obtener una combinación
de los mismos. Esta combinación se basa en dos premisas:
1. Si la clave no existe, se añade con su valor.
2. Si la clave ya existe, se añade con el valor del «último» diccionario en la mezcla.
Python ofrece dos mecanismos para realizar esta combinación. Se parte de los siguientes
diccionarios para ejemplificar su uso:
>>> rae1 = {
... ‘bifronte’: ‘De dos frentes o dos caras’,
... ‘enjuiciar’: ‘Someter una cuestión a examen, discusión y juicio’
... }
>>> rae2 = {
... ‘anarcoide’: ‘Que tiende al desorden’,
... ‘montuvio’: ‘Campesino de la costa’,
... ‘enjuiciar’: ‘Instruir, juzgar o sentenciar una causa’
... }
Sin modificar los diccionarios originales: Mediante el operador **:
>>> {**rae1, **rae2}
{‘bifronte’: ‘De dos frentes o dos caras’,
‘enjuiciar’: ‘Instruir, juzgar o sentenciar una causa’,
‘anarcoide’: ‘Que tiende al desorden’,
‘montuvio’: ‘Campesino de la costa’}

A partir de Python 3.9 podemos utilizar el operador | para combinar dos diccionarios:

>>> rae1 | rae2

{‘bifronte’: ‘De dos frentes o dos caras’,
‘enjuiciar’: ‘Instruir, juzgar o sentenciar una causa’,
‘anarcoide’: ‘Que tiende al desorden’,
‘montuvio’: ‘Campesino de la costa’}

En este caso «último» hace referencia al diccionario que se encuentra más a la derecha
en la expresión.

Si se quiere modificar uno de los diccionarios se utiliza la función update()

>>> rae1.update(rae2)
>>> rae1
{‘bifronte’: ‘De dos frentes o dos caras’,
‘enjuiciar’: ‘Instruir, juzgar o sentenciar una causa’,
‘anarcoide’: ‘Que tiende al desorden’,
‘montuvio’: ‘Campesino de la costa’}

Nota: Tener en cuenta que el orden en el que se especifican los diccionarios a la hora de
su combinación (mezcla) es relevante en el resultado final. En este caso el orden de los
factores sí altera el producto.
El diccionario que se afecta en el ejemplo es rae1

Borrar elementos
Python ofrece, al menos, tres formas para borrar elementos en un diccionario:
Por su clave: Mediante la sentencia del:
>>> rae = {
... ‘bifronte’: ‘De dos frentes o dos caras’,
... ‘anarcoide’: ‘Que tiende al desorden’,
... ‘montuvio’: ‘Campesino de la costa’}
>>> del(rae[‘bifronte’])
>>> rae
{‘anarcoide’: ‘Que tiende al desorden’, ‘montuvio’: ‘Campesino de la costa’}

Por su clave (con extracción): Mediante la función pop() podemos extraer un elemento
del diccionario por su clave. Vendría a ser una combinación de get() + del:
>>> rae = {
... ‘bifronte’: ‘De dos frentes o dos caras’,
... ‘anarcoide’: ‘Que tiende al desorden’,
... ‘montuvio’: ‘Campesino de la costa’
... }
>>> rae.pop(‘anarcoide’)
‘Que tiende al desorden’
>>> rae
{‘bifronte’: ‘De dos frentes o dos caras’, ‘montuvio’: ‘Campesino de la costa’}

>>> rae.pop(‘bucle’)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: ‘bucle’

Advertencia: Si la clave a extraer con pop() no existe, se tiene un error.

Borrado completo del diccionario:

1. Utilizando la función clear():
>>> rae = {
... ‘bifronte’: ‘De dos frentes o dos caras’,
... ‘anarcoide’: ‘Que tiende al desorden’,
... ‘montuvio’: ‘Campesino de la costa’
... }
>>> rae.clear()
>>> rae
{}
2. «Reinicializando» el diccionario a vacío con {}:
>>> rae = {
... ‘bifronte’: ‘De dos frentes o dos caras’,
... ‘anarcoide’: ‘Que tiende al desorden’,
... ‘montuvio’: ‘Campesino de la costa’
... }
>>> rae = {}
>>> rae
{}
Nota: La diferencia entre ambos métodos tiene que ver con cuestiones internas de
gestión de memoria y de rendimiento.

Copia con diccionarios

Nivel intermedio
Al igual que ocurría con las listas, si se hace un cambio en un diccionario, se verá
reflejado en todas las variables que hagan referencia al mismo. Esto se deriva de su
propiedad de ser mutable. Ejemplo concreto:
>>> original_rae = {
... ‘bifronte’: ‘De dos frentes o dos caras’,
... ‘anarcoide’: ‘Que tiende al desorden’,
... ‘montuvio’: ‘Campesino de la costa’
... }
>>> copy_rae = original_rae
>>> original_rae[‘bifronte’] = ‘bla bla bla’
>>> original_rae
{‘bifronte’: ‘bla bla bla’,
‘anarcoide’: ‘Que tiende al desorden’,
‘montuvio’: ‘Campesino de la costa’
}
>>> copy_rae
{‘bifronte’: ‘bla bla bla’,
‘anarcoide’: ‘Que tiende al desorden’,
‘montuvio’: ‘Campesino de la costa’
}
Una posible solución a este problema es hacer una «copia dura». Para ello Python
proporciona la función copy():
>>> original_rae = {
... ‘bifronte’: ‘De dos frentes o dos caras’,
... ‘anarcoide’: ‘Que tiende al desorden’,
... ‘montuvio’: ‘Campesino de la costa’
... }
>>> copy_rae = original_rae.copy()
>>> original_rae[‘bifronte’] = ‘bla bla bla’
>>> original_rae
{‘bifronte’: ‘bla bla bla’,
‘anarcoide’: ‘Que tiende al desorden’,
‘montuvio’: ‘Campesino de la costa’}
>>> copy_rae
{‘bifronte’: ‘De dos frentes o dos caras’,
‘anarcoide’: ‘Que tiende al desorden’,
‘montuvio’: ‘Campesino de la costa’}

Ejercicio:
En el ejercicio de calificaciones usando diccionarios obtener un listado con el código del
estudiante, calificaciones y calificación final ordenados ascendentemente.

Para este ejercicio se debe tener en cuenta que los diccionarios manejan dos elementos,
clave y valor, el ejercicio plantea manejar 3 elementos. Código estudiante, calificaciones y
nota final ordenado por nota final, lo cual directamente no se puede realizar.

Solución
Pasos generales del ordenamiento

Generar diccionarios con código estudiante y calificación, y código estudiante y

calificaciones
Ordenar diccionario 1 por valor
Proteger diccionario 1 en diccionario 3(para mantener el valor ordenado)
Mezclar diccionario 1 con diccionario 2 (diccionario 1 se modifica y queda con las
calificaciones de cada estudiante en orden ascendente, se pierde el valor anterior de
diccionario 1 y queda con el valor del diccionario 2)
Mostrar diccionario 1 y el valor de la protección del diccionario protegido.

Con estos pasos lo que se muestra es la información solicitada.

Las funciones que se tienen son las siguientes:

def formarDiccionarios(lc,mc,lf):
dic1={}
dic2={}
for i in range(len(lc)):
dic1[lc[i]]=lf[i]
dic2[lc[i]]=mc[i]
print('Diccionario 1\n',dic1)
print('Diccionario 2\n',dic2)
return dic1,dic2

def ordenarDiccionarioValor(dic1):
dic_ordenado = dict(sorted(dic1.items(),key=lambda item:item[1]))
print('Diccionario ordenado por valor \n',dic_ordenado)
return dic_ordenado

def combinarDiccionarios(dic1,dic2):
dic1.update(dic2)
print('Diccionario ordenado por valor calificaciones \n',dic1)
def mostrarCalificaciones2(dic1,dic2):
for key,value in dic1.items():
print('Codigo estudiante ',key)
print('calificaciones ',value)
print('calificacion final ',dic2[key])

llamado de las funciones

dic1,dic2=formarDiccionarios(lcal,mcal,lfin)
dic1=ordenarDiccionarioValor(dic1)
dic3=dic1.copy()
combinarDiccionarios(dic1,dic2)
mostrarCalificaciones2(dic1,dic2)

programa completo

def leerInt(cadena):
while True:
try:
dato=int(input(cadena))
return dato
except ValueError:
print('Error de sintaxis: Digitar valor entero')

def leerFloat(cadena):
while True:
try:
dato=float(input(cadena))
return dato
except ValueError:
print('Error de sintaxis: Digitar valor real')

def leerCalificaciones(mcalif):
# ce=int(input('Cantidad de estudiantes ->'))
ce=leerInt('Cantidad de esuudiantes -> ')
lcod=[]

for i in range(ce):
print ('Información estudiante ',i+1)
lc=[]
lcod.append(leerInt('Codigo estudiante-> '))
lc.append(leerFloat('Calificacion 1 -> '))
 lc.append(leerFloat('Calificacion 2 -> '))
lc.append(leerFloat('Calificacion 3 -> '))
mcalif.append(lc)
return lcod

def leerCalificaciones2():
# ce=int(input('Cantidad de estudiantes ->'))

lcod=[99,33,77,66,88,44]
mcalif=[[3,3,3],[5,5,5],[4,4,4],[5,5,5],[2,2,2],[2,2,2]]
print (lcod)
print (mcalif)
return lcod,mcalif

def calcularDefinitiva(lc,mc):
ldef=[]
for i in range(len(lc)):
ldef.append(mc[i][0]*.30+mc[i][1]*.30+mc[i][2]*.40)
return ldef

def formarDiccionarios(lc,mc,lf):
dic1={}
dic2={}
for i in range(len(lc)):
dic1[lc[i]]=lf[i]
dic2[lc[i]]=mc[i]
print('Diccionario 1\n',dic1)
print('Diccionario 2\n',dic2)
return dic1,dic2

def ordenarDiccionarios(dic1,dic2):
codigos_ord=sorted(dic1.keys())
dic_ordenado1={}
dic_ordenado2={}
for key in codigos_ord:
dic_ordenado1[key]=dic1[key]
dic_ordenado2[key]=dic2[key]

print('Diccionario1 ordenado por clave \n',dic_ordenado1)

print('Diccionario2 ordenado por clave \n',dic_ordenado2)

def ordenarDiccionarioValor(dic1):
 dic_ordenado = dict(sorted(dic1.items(),key=lambda item:item[1]))
print('Diccionario ordenado por valor \n',dic_ordenado)
return dic_ordenado

def combinarDiccionarios(dic1,dic2):
dic1.update(dic2)
print('Diccionario ordenado por valor calificaciones \n',dic1)

def mostrarCalificaciones2(dic1,dic2):
for key,value in dic1.items():
print('Codigo estudiante ',key)
print('calificaciones ',value)
print('calificacion final ',dic2[key])

#programa principal

lcod,mcal=leerCalificaciones2()
print('Codigos Estudiantes \n',lcod)
print('Matriz de calificaciones \n',mcal)
lfin=calcularDefinitiva(lcod,mcal)
dic1,dic2=formarDiccionarios(lcod,mcal,lfin)
ordenarDiccionarios(dic1,dic2) #ordenamiento por clave
dic1=ordenarDiccionarioValor(dic1) #ordenamiento por valor
dic3=dic1.copy() #protege el diccionario ordenado por valor
combinarDiccionarios(dic1,dic2) #en dic1 quedan la califiaciones
mostrarCalificaciones2(dic1,dic3) #

Conjuntos

Un conjunto en Python representa una serie de valores únicos y sin orden

establecido, con la única restricción de que sus elementos deben ser «hashables».
Mantiene muchas similitudes con el concepto matemático de conjunto

Creación de conjuntos
Para crear un conjunto basta con separar sus valores por comas y rodearlos de llaves {}:
>>> lottery = {21, 10, 46, 29, 31, 94}
>>> lottery
{10, 21, 29, 31, 46, 94}
La excepción la tenemos a la hora de crear un conjunto vacío, ya que, siguiendo la
lógica de apartados anteriores, deberíamos hacerlo a través de llaves:
>>> wrong_empty_set = {}
>>> type(wrong_empty_set)
dict

Advertencia: Si se hace esto, lo que se obtiene es un diccionario vacío.

La única opción que tenemos es utilizar la función set():

>>> empty_set = set()
>>> empty_set
set()
>>> type(empty_set)
set

Conversión
Para convertir otros tipos de datos en un conjunto se puede usar la función set() sobre
cualquier iterable:
>>> set(‘aplatanada’)
{‘a’, ‘d’, ‘l’, ‘n’, ‘p’, ‘t’}

>>> set([1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5])

{1, 2, 3, 4, 5}
>>> set((‘ADENINA’, ‘TIMINA’, ‘TIMINA’, ‘GUANINA’, ‘ADENINA’, ‘CITOSINA’))
{‘ADENINA’, ‘CITOSINA’, ‘GUANINA’, ‘TIMINA’}
>>> set({‘manzana’: ‘rojo’, ‘plátano’: ‘amarillo’, ‘kiwi’: ‘verde’})
{‘kiwi’, ‘manzana’, ‘plátano’}

Importante: Como se ha visto en los ejemplos anteriores, set() se suele utilizar en

muchas ocasiones como una forma de extraer los valores únicos de otros tipos de
datos. En el caso de los diccionarios se extraen las claves, que, por definición, son únicas.
Nota: El hecho de que en los ejemplos anteriores los elementos de los conjuntos estén
ordenados es únicamente un «detalle de implementación» en el que no se puede confiar.

Operaciones con conjuntos

Obtener un elemento
En un conjunto no existe un orden establecido para sus elementos, por lo tanto no se
puede acceder a un elemento en concreto.
De este hecho se deriva igualmente que no se puede modificar un elemento existente,
ya que ni siquiera tenemos acceso al mismo. Python sí nos permite añadir o borrar
elementos de un conjunto.
Añadir un elemento
Para añadir un elemento a un conjunto se utiliza la función add(). Como ya se ha
indicado, al no importar el orden dentro del conjunto, la inserción no establece a priori la
posición donde se realizará.

Ejemplo de adición

>>> # John Lennon, Paul McCartney, George Harrison y Ringo Starr

>>> beatles = set([‘Lennon’, ‘McCartney’, ‘Harrison’, ‘Starr’])
>>> beatles.add(‘Best’) # Pete Best
>>> beatles
{‘Best’, ‘Harrison’, ‘Lennon’, ‘McCartney’, ‘Starr’}
Ejercicio
Dada una tupla de duplas (2 valores), cree dos conjuntos:
• Uno de ellos con los primeros valores de cada dupla.
• El otro con los segundos valores de cada dupla.
Ejemplo

• Entrada: ((4, 3), (8, 2), (7, 5), (8, 2), (9, 1))

• Salida:
{8, 9, 4, 7}
{1, 2, 3, 5}

Borrar elementos
Para borrar un elemento de un conjunto podemos utilizar la función remove(). Siguiendo
con el ejemplo anterior, vamos a borrar al último «beatle» añadido:
>>> beatles
{‘Best’, ‘Harrison’, ‘Lennon’, ‘McCartney’, ‘Starr’}
>>> beatles.remove(‘Best)
>>> beatles
{ ‘Harrison’, ‘Lennon’, ‘McCartney’, ‘Starr’}

Longitud de un conjunto
El número de elementos (cardinalidad) que tiene un conjunto se lo obtiene con la función
len():
>>> beatles
{ ‘Harrison’, ‘Lennon’, ‘McCartney’, ‘Starr’}
>>> len(beatles)
4

Iterar sobre un conjunto

Tal como se ha visto para otros tipos de datos iterables, la forma de recorrer los
elementos de un conjunto es utilizar la sentencia for:
>>> for beatle in beatles:
... print(beatle)
...
Harrison
McCartney
Starr
Lennon

Pertenencia de elemento
Al igual que con otros tipos de datos, Python ofrece el operador in para determinar si un
elemento pertenece a un conjunto:
>>> beatles
{ ‘Harrison’, ‘Lennon’, ‘McCartney’, ‘Starr’}
>>> ‘Lennon’ in beatles
True
>>> ‘Fari’ in beatles
False
A partir de dos conjuntos 𝐴 = {1, 2} y 𝐵 = {2, 3}, ejemplificar las distintas
Teoría de conjuntos

operaciones que se pueden hacer entre ellos basadas en los Diagramas de Venn y la
Teoría de Conjuntos:

>>> A = {1, 2}
>>> B = {2, 3}

Diagramas de Venn

𝐴 ∩ 𝐵 – Elementos que están a la vez en 𝐴 y en 𝐵:

Intersección

>>> A & B
{2}
>>> A.intersection(B)
{2}

𝐴 ∪ 𝐵 – Elementos que están tanto en 𝐴 como en 𝐵:

Unión

>>> A | B
{1, 2, 3}
>>> A.union(B)
{1, 2, 3}

𝐴 − 𝐵 – Elementos que están en 𝐴 y no están en 𝐵:

Diferencia

>>> A - B
{1}
>>> A.difference(B)
{1}

𝐴 ∩ 𝐵 – Elementos que están en 𝐴 o en 𝐵 pero no en ambos conjuntos:

Diferencia simétrica

>>> A ^ B
{1, 3}

>>> A.symmetric_difference(B)
{1, 3}

• Un conjunto 𝐵 es un subconjunto de otro conjunto 𝐴 si todos los elementos de 𝐵 están

Inclusión

incluidos en 𝐴.
• Un conjunto 𝐴 es un superconjunto de otro conjunto 𝐵 si todos los elementos de 𝐵
están incluidos en 𝐴.
Ejemplo con los siguientes conjuntos:
>>> A = {2, 4, 6, 8, 10}
>>> B = {4, 6, 8}
En Python podemos realizar comprobaciones de inclusión (subconjuntos y
superconjuntos)

𝐵⊂𝐴
utilizando operadores clásicos de comparación:

>>> B < A # subconjunto

𝐵⊆𝐴
True

>>> B <= A
True

Ejercicio:
Se tienen dos matrices con datos numéricos, formar dos conjuntos con los primos de cada
matriz y realizar las operaciones de unión e intersección de conjuntos con estos dos
conjuntos

def leermatrices():
m1=[[5,7,5,],[3,3,2],[4,7,11]]
m2=[[5,7,4],[5,3,13],[2,19,13]]
return m1,m2

def leerMatriz():
m=[]
nf=int(input('Cantidad de filas -> '))
nc=int(input('Cantidad de columnas -> '))
for i in range(nf):
l1=[]
for j in range(nc):
l1.append(int(input(f'dato ({i},{j}) = ')))
m.append(l1)
return m

def primo(valor):
c=1
cd=0
while c<=valor :
if valor%c==0:
cd+=1
c+=1
if cd==2:
return True
else:
return False

def PrimosMatriz(m):
 setprimos=set()
for i in range(len(m)):
for j in range(len(m[i])):
if primo(m[i][j]):
setprimos.add(m[i][j])

return setprimos

def unionConjuntos(pr1,pr2):
print('union de conjuntos ')
print('conjunto uno \n',pr1)
print('conjunto uno \n',pr2)
print('Union de conjuntos pr1 U pr1 forma 1',pr1|pr2)
print('Union de conjuntos pr1 U pr1 forma 2',pr1.union(pr2))

def interseccionConjuntos(pr1,pr2):
print('Intersección de conjuntos ')
print('conjunto uno \n',pr1)
print('conjunto uno \n',pr2)
print('Intersección de conjuntos pr1 & pr1 forma 1',pr1&pr2)
print('Intersección de conjuntos pr1 & pr1 forma 1',pr1.intersection(pr2))

#programa principal

#print('Datos matriz 1 ')

#m1=leerMatriz()
#print('Datos matriz 2 ')
#m2=leerMatriz()

m1,m2=leermatrices()
print('matriz uno \n',m1)
print('matriz dos \n',m2)
setPrimo1=PrimosMatriz(m1)
print('primos matriz 1 \n',setPrimo1)
setPrimo2=PrimosMatriz(m2)
print('primos matriz 2 \n',setPrimo2)
unionConjuntos(setPrimo1,setPrimo2)
interseccionConjuntos(setPrimo1,setPrimo2)

Ficheros
Aunque los ficheros encajarían más en un apartado de «entrada/salida» ya que
representan un medio de almacenamiento persistente, también podrían ser vistos como
estructuras de datos, puesto que permiten guardar la información y asignarles un cierto
formato.
Un fichero es un conjunto de bytes almacenados en algún dispositivo. El sistema de
ficheros es la estructura lógica que alberga los ficheros y está jerarquizado a través de
directorios (o carpetas). Cada fichero se identifica unívocamente a través de una ruta que
nos permite acceder a él.

Lectura de un fichero
Python ofrece la función open() para «abrir» un fichero. Esta apertura se puede realizar en
3 modos distintos:

• Lectura del contenido de un fichero existente.

• Escritura del contenido en un fichero nuevo.
• Añadido al contenido de un fichero existente.

Veamos un ejemplo para leer el contenido de un fichero en el que se encuentran las

temperaturas mínimas y máximas de cada día de la última semana. El fichero está en la
subcarpeta (ruta relativa) files/temps.dat y tiene el siguiente contenido:

23 29
23 31
26 34
23 33
22 29
22 28
22 28

Lo primero será abrir el fichero:

>>> f = open(‘files/temps.dat’)

La función open() recibe como primer argumento la ruta al fichero que queremos
manejar (como un «string») y devuelve el manejador del fichero, que en este caso lo
asigna a una variable llamada f pero se le podría haber puesto cualquier otro nombre.

Nota: Es importante dominar los conceptos de ruta relativa y ruta absoluta para el
trabajo con ficheros.

Hay que tener en cuenta que la ruta al fichero que abrimos (en modo lectura) debe
existir, ya que de lo contrario obtendremos un error:

>>> f = open(‘foo.txt’)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: ‘foo.txt’

Una vez abierto el fichero ya se puede proceder a leer su contenido. Para ello Python
ofrece la posibilidad de leer todo el fichero de una vez o bien leerlo línea a línea.
Lectura completa de un fichero
Siguiendo con nuestro ejemplo de temperaturas, veamos cómo leer todo el contenido del
fichero de una sola vez. Para esta operación, Python nos provee, al menos, de dos
funciones:

read() Devuelve todo el contenido del fichero como una cadena de texto (str):
>>> f = open(‘files/temps.dat’)
>>> f.read()
‘23 29 \n23 31\n26 34\n23 33\n22 29\n22 28\n22 28\n’

readlines() Devuelve todo el contenido del fichero como una lista (list) donde cada
elemento es una línea:

>>> f = open(‘files/temps.dat’)
>>> f.readlines()

[‘23 29\n’, ‘23 31\n’, ‘26 34\n’, ‘23 33\n’, ‘22 29\n’, ‘22 28\n’, ‘22 28\n’]

Importante: Nótese que, en ambos casos, los saltos de línea \n siguen apareciendo en
los datos leídos, por lo que habría que «limpiar» estos caracteres. Para ello se
recomienda utilizar las funciones ya vistas de cadenas de texto.

Lectura línea a línea

Hay situaciones en las que interesa leer el contenido del fichero línea a línea. Cuando se
presentan ficheros de tamaño considerable (varios GB). Si se lo intenta leer
completamente este fichero de sola una vez podría ocupar demasiada RAM y reducir el
rendimiento de la máquina.
Es por ello que Python ofrece varias aproximaciones a la lectura de ficheros línea a línea.
La más usada es iterar sobre el propio manejador del fichero:

>>> f = open(‘files/temps.dat’)
>>> for line in f: # that easy!
... print(line)
...

23 29
23 31
26 34
23 33
22 29
22 28
22 28

Truco: Igual que pasaba anteriormente, la lectura línea por línea también incluye el salto
de línea \n lo que provoca un «doble espacio» entre cada una de las salidas. Bastaría con
aplicar line.split() para eliminarlo.

Escritura en un fichero

Para escribir texto en un fichero hay que abrir dicho fichero en modo escritura. Para ello
se utiliza un argumento adicional en la función open() que indica esta operación:
>>> f = open(‘files/canary-iata.dat’, ‘w’)

Nota: Si bien el fichero en sí mismo se crea al abrirlo en modo escritura, la ruta hasta ese
fichero no. Eso quiere decir que se debe asegurar que las carpetas hasta llegar a dicho
fichero existen. En otro caso se obtien un error de tipo FileNotFoundError.
Ahora ya se puede hacer uso de la función write() para enviar contenido al fichero abierto.

Ejemplo llevar el contenido de una lista en fichero especificado. En este caso partimos de
los códigos IATA de aeropuertos de las Islas Canarias.

1 >>> canary_iata = (‘TFN’, ‘TFS’, ‘LPA’, ‘GMZ’, ‘VDE’, ‘SPC’, ‘ACE’, ‘FUE’)
2
3 >>> for code in canary_iata:
4 ... f.write(code + ‘\n’)
5 ...
6
7 >>> f.close()

Nótese:
Línea 4 Escritura de cada código en el fichero. La función write() no incluye el salto de
línea por defecto, así que lo añadimos de manera explícita.
Línea 7 Cierre del fichero con la función close(). Especialmente en el caso de la escritura
de ficheros, se recomienda encarecidamente cerrar los ficheros para evitar pérdida de
datos.

Advertencia: Siempre que se abre un fichero en modo escritura utilizando el

argumento ‘w’, el fichero se inicializa, borrando cualquier contenido que pudiera tener.

Añadido a un fichero
La única diferencia entre añadir información a un fichero y escribir información en un
fichero es el modo de apertura del fichero. En este caso utilizamos ‘a’ por «append»:
>>> f = open(‘more-data.txt’, ‘a’)

En este caso el fichero more-data.txt se abrirá en modo añadir con lo que las llamadas a
la función write() hará que aparezcan nueva información al final del contenido ya existente
en dicho fichero.

Usandos contextos
Python ofrece gestores de contexto como una solución para establecer reglas de entrada
y salida a un determinado bloque de código.
En el caso que nos ocupa, usaremos la sentencia with y el contexto creado se ocupará de
cerrar adecuadamente el fichero que hemos abierto, liberando así sus recursos:

1 >>> with open(‘files/temps.dat’) as f:

2 ... for line in f:
3 ... max_temp, min_temp = line.strip().split()
4 ... print(max_temp, min_temp)
5 ...

29 23
31 23
34 26
33 23
29 22
28 22
28 22
Línea 1 Apertura del fichero en modo lectura utilizando el gestor de contexto definido por
la palabra reservada with.
Línea 2 Lectura del fichero línea a línea utilizando la iteración sobre el manejador del
fichero.
Línea 3 Limpieza de saltos de línea con strip() encadenando la función split() para separar
las dos temperaturas por el carácter espacio.
Línea 4 Imprimir por pantalla la temperatura mínima y la máxima.

Nota: Es una buena práctica usar with cuando se manejan ficheros. La ventaja es que el
fichero se cierra adecuadamente en cualquier circunstancia, incluso si se produce
cualquier tipo de error

Hay que prestar atención a la hora de escribir valores numéricos en un fichero, ya que el
método write() por defecto espera ver un «string» como argumento:

>>> lottery = [43, 21, 99, 18, 37, 99]

>>> with open(‘files/lottery.dat’, ‘w’) as f:
... for number in lottery:
... f.write(number + ‘\n’)
...
Traceback (most recent call last):
File "<stdin>", line 3, in <module>
TypeError: write() argument must be str, not int

Importante: Para evitar este tipo de errores, se debe convertir a str aquellos valores que
queramos usar con la función write() para escribir información en un fichero de texto. Los
f-strings son tu aliado.

Ejercicio
Dado el fichero temperatures.txt con 12 filas (meses) y 31 columnas (temperaturas de
cada día), se pide:

1. Leer el fichero de datos.

2. Calcular la temperatura media de cada mes.
3. Escribir un fichero de salida avg_temps.txt con 12 filas (meses) y la temperatura media
de cada mes con 2 decimales.
Guarda el fichero en la misma carpeta en la que vas a escribir tu código. Así evitarás
problemas de rutas relativas/absolutas.
Comprobación de resultados:

26.29
23.65
25.84
24.35
27.03
24.52
27.90
26.39
26.32
25.71
27.32
26.00

Dentro del manejo de archivos es muy importante tener en cuenta las siguientes
funciones asociadas con cadenas
Función split() para dividir una cadena
Función sprit() para limpiar cadena

Esto porque en los archivos, lo que se almacena y recupera son string o cadenas.

Dividir una cadena

Una tarea muy común al trabajar con cadenas de texto es dividirlas por algún tipo de
separador. En este sentido, Python ofrece la función split(), que se debe usar
anteponiendo el «string» que queramos dividir:

>>> proverb = ‘No hay mal que por bien no venga’

>>> proverb.split()
[‘No’, ‘hay’, ‘mal’, ‘que’, ‘por’, ‘bien’, ‘no’, ‘venga’]

>>> tools = ‘Martillo,Sierra,Destornillador’

>>> tools.split(‘,’)

[‘Martillo’, ‘Sierra’, ‘Destornillador’]

Limpiar cadenas
Cuando se lee datos del usuario o de cualquier fuente externa de información, es
bastante probable que se incluyan en esas cadenas de texto, caracteres de relleno al
comienzo y al final. Python ofrece la posibilidad de eliminar estos caracteres u otros que
no interesen.
La función strip() se utiliza para eliminar caracteres del principio y del final de un «string».
También existen variantes de esta función para aplicarla únicamente al comienzo o
únicamente al final de la cadena de texto.
Ejemplo. Procesar un fichero con números de serie de un determinado artículo. Cada
línea contiene el valor que interesa pero se han «colado» ciertos caracteres de relleno
que debemos limpiar:

>>> serial_number = 􀀉\n\t \n 48374983274832 \n\n\t \t \n􀀉

>>> serial_number.strip()
‘48374983274832’

Nota: Si no se especifican los caracteres a eliminar, strip() usa por defecto cualquier
combinación de espacios en blanco, saltos de línea \n y tabuladores \t.
Para hacer «limpieza» por la izquierda (comienzo) y por la derecha (final) se utilizan la
función lstrip() y rstrip() respectivamente:

Ejemplo
Lista 6: «Left strip»
>>> serial_number.lstrip()
‘48374983274832 \n\n\t \t \n’

Determinar la existencia de un archivo

os.path.exists()

os operating system

El módulo del sistema operativo (os) proporciona múltiples funciones para interactuar con
el sistema operativo. Para comprobar si existe un archivo o carpeta podemos utilizar
el camino.existe () función que acepta la ruta al archivo o directorio como argumento.
Devuelve un valor booleano basado en la existencia de la ruta.

Nota: Una ruta es la ubicación única de un archivo o directorio en un sistema de archivos.

En Python, el os.ruta El submódulo contiene funciones diseñadas exclusivamente para

operar con rutas de archivo. Todas estas funciones aceptan el argumento de ruta como
cadenas o bytes, y puede decidir trabajar con rutas absolutas, por ejemplo:

/home/daniel/.bashrc

O con rutas relativas, dependiendo del directorio en el que esté ejecutando el script:

.bashrc
# Running the script in my home folder

Aquí hay varios ejemplos que utilizan el os.path.exists () función, ejecutándose en el

directorio donde se encuentran mis archivos de prueba:

In [1]: import os

In [2]: os.path.exists('testfile.txt')
Out[2]: True

In [3]: os.path.exists('testdirectory')
Out[3]: True

In [4]: os.path.exists('hey-i-dont-exist')
Out[4]: False

Como se ve, vuelve Verdadero al probar con el archivo de prueba.txt archivo y

el directorio de prueba carpeta exis, y Falso cuando el archivo no existe.

os.path.isfile()
Si solo quisiera probar la existencia de un archivo (no un directorio), llamaría
al os.path.isfile () función.

In [1]: import os

In [2]: os.path.isfile('testfile.txt')
Out[2]: True

In [3]: os.path.isfile('testdirectory/')
Out[3]: False

In [4]: os.path.isfile('i-dont-even-exist')
Out[4]: False

In [5]: os.path.isfile('testdirectory/otherfile.txt')
Out[5]: True
Copy
Ejercicio.

Realizar el ejercicio de las calificaciones con los siguientes requerimientos funcionales.

-Cargar las calificaciones desde el teclado o desde un archivo

Determinar si el archivo calificaciones.dat existe
Si existe cargar las listas lc, mc
Si no existe iniciar listas y cargar información desde el teclado
-Realizar los informes

-Almacenar la información de los estudiantes con sus calificaciones

-Almacenar información de los diccionarios en forma de valor

El ejercicio anterior está determinado con menús para hacer un seguimiento lógico de la
información.

import os
sw1=False
def leerCalificacionesEstaticas():
# ce=int(input('Cantidad de estudiantes ->'))

lcod=[99,33,77,66,88,44]
mcalif=[[3,3,3],[5,5,5],[4,4,4],[5,5,5],[2,2,2],[2,2,2]]

print (lcod)
print (mcalif)
return lcod,mcalif

def leerCalificacionesTeclado(mcalif):
# ce=int(input('Cantidad de estudiantes ->'))
 ce=leerInt('Cantidad de estudiantes -> ')
lcod=[]

for i in range(ce):
print ('Información estudiante ',i+1)
lc=[]
lcod.append(leerInt('Codigo estudiante-> '))
lc.append(leerFloat('Calificacion 1 -> '))
lc.append(leerFloat('Calificacion 2 -> '))
lc.append(leerFloat('Calificacion 3 -> '))
mcalif.append(lc)
return lcod

def leerCalificacionesArchivo():
fcal=open('calificaciones.dat')
lc=[]
lm=[]
lf=[]
lm1=[]
#fcal.readlines
# print(fcal.read())
for line in fcal:
lc1=fcal.readline().strip().split()
lc.append(int(lc1[0]))
lm1=[]
lm1.append(float(lc1[1]))
lm1.append(float(lc1[2]))
lm1.append(float(lc1[3]))
lm.append(lm1)
lf.append(float(lc1[4]))

def leerCalificacionesArchivo2():

try:
while True:
archivo=input('nombre del archivo ')
if os.path.exists(archivo):
fcal=open(archivo)

lc=[]
lm=[]
lf=[]
lm1=[]
lc1=fcal.readlines()
 for cal in lc1:
lc1=cal.strip().split()
lc.append(int(lc1[0]))
lm1=[]
lm1.append(float(lc1[1]))
lm1.append(float(lc1[2]))
lm1.append(float(lc1[3]))
lm.append(lm1)
lf.append(float(lc1[4]))
print(lc)
print(lm)
print(lf)
return lc,lm,lf
else:
print('archivo no existe ')
print('Continuar S/N')
resp=input('opcion -> ')
if resp=='n' or resp=='N':
print('no se abre archivo')
return None,None,None

except FileNotFoundError:
print('Error problemas al abrir archivo ')

def leerInt(cadena):
while True:
try:
dato=int(input(cadena))
return dato
except ValueError:
print('Error de sintaxis: Digitar valor entero')

def leerFloat(cadena):
while True:
try:
dato=float(input(cadena))
return dato
except ValueError:
print('Error de sintaxis: Digitar valor real')

def calcularDefinitiva(lc,mc):
ldef=[]
for i in range(len(lc)):
 ldef.append(mc[i][0]*.30+mc[i][1]*.30+mc[i][2]*.40)
return ldef

def ordenarCalificaciones(lc,mc,lf):
for i in range(len(lc)):
for j in range(i,len(lc)):
if lf[j]>lf[i]:
aux=lf[i]
lf[i]=lf[j]
lf[j]=aux
# para mentener referencia se debe hacer intercambiar
la listas
# relacionadas mc y lc
laux=mc[i].copy()
mc[i]=mc[j].copy()
mc[j]=laux.copy()
aux=lc[i]
lc[i]=lc[j]
lc[j]=aux

def promedioCalificaciones(lf):
prom=sum(lf)/len(lf)
print('\npromedio calificaciones = ',prom)

def ganadosPerdidos(lf):
cg=0
cp=0
for i in range(len(lf)):
if lf[i]>3:
cg=cg+1
else:
cp=cp+1
print('Estudiantes que ganaron la materia ',cg)
print('Estudiantes que perdieron la materia = ',cp)

def EstudiantesGanadosMateria(lc,lf):
cg=0
sg=0
for i in range(len(lf)):
if lf[i]>=3:
print('Codigo ',lc[i],' Calificacion -> ',lf[i])
cg=cg+1
sg=sg+lf[i]
if cg>0:
 pr=sg/cg
print('Estudiantes que ganaron la materia ',cg)
print('Promedio de calificacion = ',pr)

def EstudiantesPerdieronMateria(lc,lf):
cp=0
sp=0
for i in range(len(lf)):
if lf[i]<3:
print('Codigo ',lc[i],' Calificacion -> ',lf[i])
cp=cp+1
sp=sp+lf[i]
if cp>0:
pr=sp/cp
print('Estudiantes que perdieron la materia ',cp)
print('Promedio de calificacion = ',pr)

def estudiantesNotaMayor(lc,lf):
mayor=max(lf)

print('Estudiantes con nota mayor ',mayor)

for i in range(len(lc)):
if mayor==lf[i]:
print('codigo -> ',lc[i])

def estudiantesNotaMenor(lc,lf):

menor=min(lf)

print('\nEstudiantes con nota menor ',menor)

for i in range(len(lc)):
if menor==lf[i]:
print('codigo -> ',lc[i])

def mostrarCalificaciones(lc,mc,lf):
for i in range(len(lf)):
print(f'Codigo estudiante {lc[i]}')
print(f'n1 = {mc[i][0]}\n n2= {mc[i][1]}\n n3= {mc[i][2]}')
print('calificacion final -> ',lf[i])

def almacenarCalificaciones(lcod,mcal,lfin):
fcal=open('calificaciones.dat','w')
for i in range(len(lcod)):
 fcal.write(str(lcod[i])+' '+str(mcal[i][0])+' '+str(mcal[i]
[1])+' '+str(mcal[i][2])+' '+str(lfin[i])+'\n')
fcal.close()

def listadoGeneral(lcod,mcal,lf):

lfin=calcularDefinitiva(lcod,mcal)
ordenarCalificaciones(lcod,mcal,lfin)
mostrarCalificaciones(lcod,mcal,lfin)
promedioCalificaciones(lfin)
ganadosPerdidos(lfin)
estudiantesNotaMayor(lcod,lfin)
estudiantesNotaMenor(lcod,lfin)

def almacenarCalificaciones2(lcod,mcal,lfin):

try:
while True:
archivo=input('nombre del archivo ')
if os.path.exists(archivo):
print('archivo existe. desea sobreescribirlo? ')
resp=input('S/N')
if resp=='s' or resp=='S':
fcal=open(archivo,'w')
else:
fcal=open(archivo,'a')
for i in range(len(lcod)):
fcal.write(str(lcod[i])+' '+str(mcal[i][0])+'
'+str(mcal[i][1])+' '+str(mcal[i][2])+' '+str(lfin[i])+'\n')
break
else:
print('archivo no existe ')
print('Continuar S/N')
resp=input('opcion -> ')
if resp=='n' or resp=='N':
return
fcal=open(archivo,'w')
for i in range(len(lcod)):
fcal.write(str(lcod[i])+' '+str(mcal[i][0])+'
'+str(mcal[i][1])+' '+str(mcal[i][2])+' '+str(lfin[i])+'\n')
print('se han grabado ',len(lcod),' Registros ')
os.system('pause')
sw=True

except FileNotFoundError:
 print('Error problemas al abrir archivo ')
finally:
fcal.close()

def menuResultados(lc,mc,lf):
while True:
print ('Menu Resultados')
print('------------------------------')
print('1. Listado calificaciones ')
print('2. Ordenar Calificaciones ')
print('3. Estudiantes nota mayor ')
print('4. Estudiante nota menor ')
print('5. Estudiantes que ganaron ')
print('6. Estudiantes que perdieron')
print('7. Promedio Calificaciones ')
print('8. Listado general ')
print('9. Salir ')
print('------------------------------ ')

opcion=leerInt('Opcion --> ')

if opcion==1:
mostrarCalificaciones(lc,mc,lf)
elif opcion==2:
ordenarCalificaciones(lc,mc,lf)
elif opcion==3:
estudiantesNotaMayor(lc,lf)
elif opcion==4:
estudiantesNotaMenor(lc,lf)
elif opcion==5:
EstudiantesGanadosMateria(lc,lf)
elif opcion==6:

EstudiantesPerdieronMateria(lc,lf)
elif opcion==7:
promedioCalificaciones(lf)
elif opcion==8:
listadoGeneral(lc,mc,lf)

elif opcion==9:

break

def menuEvaluaciones():
 while True:
print ('Menu Resultados')
print('------------------------------')
print('1. Evaluación 1 ')
print('2. Evaluación 2 ')
print('3. Evaluación 3 ')
print('4. Salir ')
print('------------------------------ ')

opcion=leerInt('Opcion --> ')

if opcion==1:
menuCalificaciones()
elif opcion==2:
menuEvaluaciones()
elif opcion==3:
menuTrabajos()
elif opcion==4:
break

def menuTrabajos():
while True:
print ('Menu Trabajos')
print('------------------------------')
print('1. Vectores ')
print('2. Matrices ')
print('3. Matrices Vectores ')
print('4. Cadenas')
print('5. Aplicación ')
print('6. Salir ')
print('------------------------------ ')

opcion=leerInt('Opcion --> ')

if opcion==1:
menuCalificaciones()
elif opcion==2:
menuEvaluaciones()
elif opcion==3:
menuTrabajos()
elif opcion==4:
break
def menuLeerCalificaciones():
while True:
print ('Menu Entrada de datos')
print('------------------------------')
print('1. Leer Calificaciones teclado ')
print('2. Definir calificaciones estáticas ')
print('3. Cargar Calificaciones Archivo ')
print('4. Salir')
print('------------------------------ ')

opcion=leerInt('Opcion --> ')

if opcion==1:
lc,mc=leerCalificacionesTeclado()
elif opcion==2:
lc,mc=leerCalificacionesEstaticas()
elif opcion==3:
lc,mc,lf=leerCalificacionesArchivo2()
elif opcion==4:
break

return lc,mc

def menuCalificaciones():
b=False
sw1=False
while True:
print ('Menu Calificaciones')
print('------------------------------')
print('1. Leer Calificaciones ')
print('2. Calcular Definitivas ')
print('3. Resultados Generales ')
print('4. Archivar información ')
print('5. Salir')
print('------------------------------ ')

opcion=leerInt('Opcion --> ')

if opcion==1:
if b==False:
lc,mc=menuLeerCalificaciones()
b=True
else:
print('ya se tienen calificaciones. ')
 os.system("pause")
elif opcion==2:
if b==False:
print('no se han leido las calificaciones. Realizar
opcion 1.')

os.system("pause")
else:
lf=calcularDefinitiva(lc,mc)

elif opcion==3:
if b==False:
print('no se han leido las calificaciones. Realizar
opcion 1.')

os.system("pause")
else:
menuResultados(lc,mc,lf)

elif opcion==4:
if b==False:
print('no se tienen calificaciones. Realizar opcion
1.')

os.system("pause")
else:
if sw1==False:
almacenarCalificaciones2(lc,mc,lf)
sw1=True

elif opcion==5:
if sw1==False:
print('La información de calificaciones no se ha
actualizado en archivo ')
resp=input('Desea almacenarla s/n ')
if resp=='s' or resp=='S':
almacenarCalificaciones2(lc,mc,lf)
sw1=True

print('Regresa al menu principal ')

os.system("pause")

break
def menuGeneral():
while True:
print ('Menu Principal')
print('------------------------------')
print('1. Ejercicio calificaciones ')
print('2. Ejercicios examenes ')
print('3. Trabajos')
print('4. Salir ')
print('------------------------------ ')

opcion=leerInt('Opcion --> ')

if opcion==1:
menuCalificaciones()
elif opcion==2:
menuEvaluaciones()
elif opcion==3:
menuTrabajos()
elif opcion==4:
break

#programa principal
sw=False
menuGeneral()

Ejercicio
Trabajo con conjuntos y cadenas

Se tiene dos cadena con caracteres alfabéticos y dígitos, formar dos

cadenas de la siguiente forma:

Cadena1 con los dígitos sin repetidos y sin comunes de las dos
cadenas

Cadena2 con los caracteres alfabéticos comunes y sin repetidos.

Solución 1 sin utilizar conjuntos

def llenarCadena1(cad1,cad2):
cadena=''
for car in cad1:
if car.isdigit()==True:
 c=car in cad2
if c==False:
b=car in cadena
if b==False:
cadena+=car
for car in cad2:
if car.isdigit()==True:
c=car in cad1
if c==False:
b=car in cadena
if b==False:
cadena+=car
return cadena

def llenarCadena2(cad1,cad2):
cadena=''
for car in cad1:
if car.isalpha()==True:
b=car in cad2
if b==True:
c=car in cadena
if c==False:
cadena+=car
return cadena

cadena1='ax1bxx2cda6dc'
cadena2='a7911cdfg328'
cad1=llenarCadena1(cadena1,cadena2)
cad2=llenarCadena2(cadena1,cadena2)

print('cadena 1 ',cad1)
print('cadena 2 ',cad2)

l1=list(cad1)
l1.sort()
cad3="".join(l1)
print(cad3)
l2=list(cad2)
l2.sort()
cad4="".join(l2)
print(cad4)
Solución 2 con conjuntos

def llenarCadena1(cad1,cad2):
sc1=set(cad1)
sc2=set(cad2)
sd1=set()
for car in cad1:
if car.isdigit():
sd1.add(car)
sd2=set()
for car in cad2:
if car.isdigit():
sd2.add(car)
sdif=sd1.symmetric_difference(sd2)
l1=list(sdif)
l1.sort()
cad3="".join(l1)
return cad3

def llenarCadena2(cad1,cad2):
sc1=set(cad1)
sc2=set(cad2)
sd1=set()
for car in cad1:
if car.isalpha():
sd1.add(car)
sd2=set()
for car in cad2:
if car.isalpha():
sd2.add(car)
sdif=sd1.intersection(sd2)
l1=list(sdif)
l1.sort()
cad3="".join(l1)
return cad3

cadena1='ax1bxx2cda6dc'
cadena2='a7911cdfg328'
cad1=llenarCadena1(cadena1,cadena2)
cad2=llenarCadena2(cadena1,cadena2)

print('cadena 1 ',cad1)
print('cadena 2 ',cad2)
Ejercicio
Realizar un programa que permita manjar la clasificación de un torneo
de fútbol, con una cantidad dada de equipos. El programa debe
permitir manejar la siguiente información:

Cantidad de equipos
Nombre del equipo
Puntos por cada partido
Goles favor
Goles contra

Numero de fechas es constante 10, se lo puede volver variable.

Por cada fecha se tiene uno de los siguientes valores que significan
la cantidad de puntos obtenida.

0 partido perdido
1 partido empatado
3 partido ganado

Se solicita:

Puntaje total obtenido por cada equipo.

Clasificación general del equipo.
Mantener la información en un archivo.

La primera vez que se hace la entrada de la información puede ser por teclado o en forma
estática.
A partir de la segunda, la información se la carga desde un archivo

El siguiente ejercicio no tiene en cuenta los goles a favor y los goles en contra, dato
importante para obtener orden en la clasificación cuando hay puntajes similares.

El nombre del archivo que se le va a dar para almacenar la información, debe ser sin
extensión o .txt

En los nombres de los equipos debe tener presente no incluir espacios en blanco

Esta realizado con menús, los cuales establecen un orden para su ejecución.

#Realizar un programa que permita llevar el control de la puntuación

de un
# equipo de futbol participante de un torneo de 10 fechas

import os
sw1=False
def leerInformacionEstaticas():
# ce=int(input('Cantidad de estudiantes ->')
 Ce=10
lequipos=['equipo1','equipo2','equipo3','equipo4',

'equipo5','equipo6','equipo7','equipo8','equipo9','equipo10']
partidos=[[0,1,0,0,0,1,3,3,1,0],[0,1,1,1,0,1,3,3,1,0],
[0,1,0,0,0,1,3,3,1,0],[0,1,1,1,0,1,3,3,1,0],
[0,1,3,3,0,1,1,1,1,0],[0,1,0,0,0,1,3,3,1,0],
[0,1,1,0,0,1,3,1,1,0],[0,1,1,3,0,1,0,0,1,0],
[3,1,3,3,0,1,1,0,1,0],[3,1,0,3,0,1,1,3,1,1]]

print (lequipos)
print (partidos)
return lequipos,partidos

def leerInformacionTeclado():
# ce=int(input('Cantidad de estudiantes ->'))
ce=leerInt('Cantidad de equipos-> ')
lequipos=[]
partidos=[]
for i in range(ce):
print ('Información equipos ',i+1)
lp=[]
lequipos.append(leerInt('nombre del equipo -> '))
print('puntos por partido')
for i in range(11):
lp.append(leerInt(f'partido {i} -> '))

partidos.append(lp)
return lequipos,partidos

def leerInformacionArchivo2():

try:
while True:
archivo=input('nombre del archivo ')
if os.path.exists(archivo):
fcal=open(archivo)

lequipo=[]
lpartidos=[]

lm1=[]
lequipo1=fcal.readlines()
for equi in lequipo1:
 lequi=equi.strip().split()
lequipo.append(lequi[0])
lm1=[]
for i in range(1,11):
lm1.append(int(lequi[i]))
lpartidos.append(lm1)
print('información equipos ')
for i in range(11):
print('equipo ',lequipo)
print('partidos ',lpartidos)
return lequipo,lpartidos
else:
print('archivo no existe ')
print('Continuar S/N')
resp=input('opcion -> ')
if resp=='n' or resp=='N':
print('no se abre archivo')
return None,None

except FileNotFoundError:
print('Error problemas al abrir archivo ')

def leerInt(cadena):
while True:
try:
dato=int(input(cadena))
return dato
except ValueError:
print('Error de sintaxis: Digitar valor entero')

def leerFloat(cadena):
while True:
try:
dato=float(input(cadena))
return dato
except ValueError:
print('Error de sintaxis: Digitar valor real')

def calcularPuntuacion(le,lp):
lfinal=[]
for equi in lp:
sum=0
for r in equi:
 sum+=r
lfinal.append(sum)
print(le)
print(lfinal)
return lfinal

def calcularClasificacion(le,lpar,lf):
for i in range(len(le)):
for j in range(i,len(le)):
if lf[j]>lf[i]:
aux=lf[i]
lf[i]=lf[j]
lf[j]=aux
# para mentener referencia se debe hacer intercambiar
la listas
# relacionadas mc y lc
laux=lpar[i].copy()
lpar[i]=lpar[j].copy()
lpar[j]=laux.copy()
aux=le[i]
le[i]=le[j]
le[j]=aux

def promedioPuntuacion(lf):
prom=sum(lf)/len(lf)
print('\npromedio de puntuaciones = ',prom)

def equiposMayorPuntuacion(lc,lf):
mayor=max(lf)

print('Equipos con puntuación mayor ',mayor)

for i in range(len(lc)):
if mayor==lf[i]:
print('codigo -> ',lc[i])

def equiposMenorPuntuacion(lc,lf):
menor=min(lf)

print('Equipos con puntuación menor ',menor)

for i in range(len(lc)):
 if menor==lf[i]:
print('codigo -> ',lc[i])

def mostrarPuntuacion(lc,mc,lf):
for i in range(len(lf)):
print(f'equipo {lc[i]}')
print(mc[i])
print('puntuación final -> ',lf[i])

def almacenarCalificaciones(lcod,mcal,lfin):
fcal=open('calificaciones.dat','w')
for i in range(len(lcod)):
fcal.write(str(lcod[i])+' '+str(mcal[i][0])+' '+str(mcal[i]
[1])+' '+str(mcal[i][2])+' '+str(lfin[i])+'\n')
fcal.close()

def almacenarInformacion2(lcod,mpar):

try:
while True:
archivo=input('nombre del archivo ')
if os.path.exists(archivo):
print('archivo existe. desea sobreescribirlo? ')
resp=input('S/N')
if resp=='s' or resp=='S':
fcal=open(archivo,'w')
else:
fcal=open(archivo,'a')

else:
print('archivo no existe ')
print('Continuar S/N')
resp=input('opcion -> ')
if resp=='n' or resp=='N':
return
fcal=open(archivo,'w')

for i in range(len(lcod)):
registro=lcod[i]
for j in range(len(mpar[i])):
registro=registro+' '+str(mpar[i][j])
registro=registro+'\n'
fcal.write(registro)
print('se han grabado ',len(lcod),' Registros ')
 os.system('pause')
sw=True
break

except FileNotFoundError:
print('Error problemas al abrir archivo ')
finally:
fcal.close()

def menuLeerInformacion():
while True:
print ('Menu Entrada de datos')
print('------------------------------')
print('1. Leer partidos teclado ')
print('2. Definir partidos estáticas ')
print('3. Cargar Partidos Archivo ')
print('4. Salir')
print('------------------------------ ')

opcion=leerInt('Opcion --> ')

if opcion==1:
le,lp=leerInformacionTeclado()
elif opcion==2:
le,lp=leerInformacionEstaticas()
elif opcion==3:
le,lp=leerInformacionArchivo2()
elif opcion==4:
break

return le,lp

def menuTorneo():
b=False
sw1=False
while True:
print('-----------------------------')
print ('Menú Torneo Futbol')
print('------------------------------')
print('1. Leer Información equipos ')
print('2. Calcular puntuación ')
print('3. Obtener Clasificación ')
print('4. Almacenar información ')
print('5. Mostrar Puntuación ')
 print('6. Salir ')
print('------------------------------ ')

opcion=leerInt('Opcion --> ')

if opcion==1:
if b==False:
lc,mc=menuLeerInformacion()
if len(lc)>0:
b=True
else:
print('no se tienen información. Opcion 1 ')
os.system('pause')
else:
print('ya se tiene información. ')
os.system("pause")
elif opcion==2:
if b==False:
print('no se han leido información. Realizar opcion
1.')

os.system("pause")
else:
lf= calcularPuntuacion(lc,mc)

elif opcion==3:
if b==False:
print('no se han leido información. Realizar opcion
1.')

os.system("pause")
else:
calcularClasificacion(lc,mc,lf)

elif opcion==4:
if b==False:
print('no se tienen información. Realizar opcion 1.')

os.system("pause")
else:
if sw1==False:
almacenarInformacion2(lc,mc)
sw1=True
 elif opcion==5:
if b==False:
print('no se tienen información. Realizar opcion 1.')

os.system("pause")
else:
if sw1==False:
mostrarPuntuacion(lc,mc,lf)
sw1=True

elif opcion==6:
if sw1==False:
print('La información no se ha actualizado en
archivo ')
resp=input('Desea almacenarla s/n ')
if resp=='s' or resp=='S':
almacenarInformacion2(lc,mc)
sw1=True

print('Regresa al menu principal ')

os.system("pause")
break

#programa principal
sw=False
menuTorneo()