UNIVERSIDAD NACIONAL DE INGENIERIA

FACULTAD DE INGENIERIA ELECTRICA Y

ELECTRONICA

ALGORITMOS Y
ESTRUCTURA DE DATOS II
Profesor: Uwe Rojas Villanueva
[email protected]

Ciclo 2023_1
 Contenido Clase 01
• Concepto de algoritmo
• Etapas de un algoritmo
• Diagrama de flujo
• Pseudocodigo y código Python
• Introducción a Python
• Índice Tiobe diciembre 2021
• Algunas empresas que utilizan Python
• Tipos de datos
• Variables
• Operadores aritméticos, relacionales, de asignación, lógicos, de cadena
 Concepto de algoritmo
• Un algoritmo es una secuencia finita de instrucciones, reglas o pasos que describen de modo preciso las
operaciones que una computadora debe realizar para ejecutar una tarea determinada, en un tiempo finito
[Donald E. Knuth. The Art of Computer Programming].
• La resolución de un problema exige el diseño de un algoritmo que resuelva el problema propuesto.

• Las dos herramientas más comunes utilizadas para el diseño de algoritmos son: diagramas de flujo y
pseudocódigos.
1. Diagrama de flujo. Representación gráfica de un algoritmo.
2. Pseudocódigo. Lenguaje de especificación de algoritmos, mediante palabras similares al inglés o español.
 Etapas de un algoritmo
• Datos de Entrada: Son los datos iniciales. Por ejemplo, el porcentaje del IGV, la fecha de nacimiento de un
empleado, el porcentaje de descuento en una tienda, el tipo de cambio, etc.
• Datos Intermedios (Proceso): Los datos que creamos internamente para ayudarnos a resolver el problema.
Generalmente provienen de aplicar una fórmula. Por ejemplo, el valor del IGV en una compra (IGV =
PorcentajeIGV * ValorDeVenta).
• Datos de Salida: Es lo que se desea calcular. Por ejemplo, el pago final que realiza el comprador incluido el
IGV (ValorDeCompra = ValorDeVenta + IGV)
Ejemplo:
Datos de Datos de salida:
entrada: Fresa, Mermelada de
Azúcar, Limón Fresa

Datos intermedios
 Ejemplo
• Una persona ingresa a una casa de cambio para cambiar sus dólares y euros a soles.
¿Cuántos soles en total recibirá a cambio?.
Solución:
Datos de entrada:
Cantidad de dólares = D
S/ 4.071 S/ 4.081
Cantidad de euros = E
S/ 4.697 S/ 5.029
Tipo de cambio Dólares a Soles = TDS = 4.071
Tipo de cambio Euros a Soles = TES = 4.697
Datos intermedios (Proceso):
Cantidad Dólares a Soles = DS
Cantidad Euros a Soles= ES
DS = D * TDS
ES = E * TES
T = DS + ES
Datos de salida:
Cantidad total = T
 Diagrama de flujo
• Un diagrama de flujo es la representación gráfica de un algoritmo.

Inicio Terminal: Indica el principio o fin de un programa.

Leer Entrada/Salida: Indica una operación de entrada

D, E, TDS, TES o salida de datos.

Proceso: Indica cálculo o manipulación de datos.

DS = D * TDS
ES = E * TES
T = DS + ES
Líneas de flujo: Indica el flujo lógico del algoritmo.

Escribir
T
Decisión: Indica una operación condicional que
determina cuál de dos caminos tomará el programa.
Fin
 Pseudocódigo y código Python
• El pseudocódigo es un lenguaje de especificación de algoritmos, mediante palabras similares al inglés o
español.

Pseudocódigo Código Python

1. INICIO 1. #INICIO
2. Leer D 2. D=int(input("Ingrese la cantidad de dólares: "))
3. Leer E 3. E=int(input("Ingrese la cantidad de euros: "))
4. Leer TDS 4. TDS=float(input("Ingrese el tipo de cambio de dólares a soles: "))
5. Leer TES 5. TES=float(input("Ingrese el tipo de cambio de euros a soles: "))
6. Calcular DS = D * TDS 6. DS=D*TDS
7. Calcular ES = E * TES 7. ES=E*TES
8. Calcular T = DS + ES 8. T=DS+ES
9. Escribir T 9. print("El total en soles es: ",T)
10.FIN 10.#FIN
 Tipos de datos
• En Python los tipos básicos se dividen en:
• Números: como pueden ser 3 (entero), 15.57 (de coma flotante) o 7 + 5j (complejos)
• Cadenas de texto: como "Hola Mundo"
• Valores booleanos: True (cierto) y False (falso).
Ejemplo:
# esto es una cadena # y esto es un numero complejo
c = "Hola Mundo" n = 7 + 8j
# esto es un entero # podemos comprobarlo con la funcion type
e = 23 print (type(c))
# esto es un numero flotante print (type(e))
f = 3.1416 print (type(f))
# esto es un valor de verdad print (type(v))
v = True print (type(n))
 Variables
• Las variables en Python no poseen un tipo intrínseco definido de manera predeterminada y una misma
variable puede contener en diferentes estados de ejecución de un programa diferentes tipos de datos
(entero, cadena, float, etc.). Esto se denomina tipado dinámico.
• La sentencia de asignación (=) representa el mecanismo mediante el cual una variable es vinculada a su
valor.
Ejemplo:
# x es una cadena
x = "Hola Mundo"
print (type(x))
# ahora x es un entero
x = 23
print (type(x))
# y ahora x es un valor de verdad
x = False
print (type(x))
Operadores aritméticos
Operadores relacionales
Operadores de asignación
Operadores lógicos
 Operadores de cadena
• Las cadenas son caracteres encerrado entre comillas simples ('cadena 123 #$') o comillas dobles ("cadena
123 #$").
• Dentro de las comillas se pueden añadir caracteres especiales mediante la barra invertida \, como \n, el
carácter de nueva línea, o \t, el de tabulación, o \" una comilla doble.
• Los operadores de cadena son:
+ (concatenación)
* (repetición) Ejemplo:
#El saludo
saludo = "Hola " + "\"Mundo\""
c = 4 * "co"
print (saludo+"\n"+"El gallo dice: "+c)
 Contenido Clase 02
• Estructuras condicionales
• La sentencia if
• La sentencia if-else
• La sentencia if-else anidada
• La sentencia elif
• Estructuras repetitivas
• Bucle while
• El contador
• El acumulador
• La sentencia break
• La sentencia continue
• Bucle for-in
 Estructuras condicionales
• Las estructuras de control condicionales, son aquellas que nos permiten evaluar si una o más condiciones
se cumplen, para decir qué acción vamos a ejecutar.
• Entre las sentencias condicionales tenemos:
▪ If
▪ if-else
▪ elif
 La sentencia if
• La sentencia if hace que una o más sentencias se ejecuten solo cuando su condición es verdadera. Es la
sentencia condicional más básica.
Ejemplo: Averigüe si un número es par.
n=int(input("Ingrese un número entero: "))
if n%2==0:
print("El número es par")
print("Fin")
Ejemplo: Solo permita el ingreso si el password es correcto.
pas=input("Password: ")
if pas in ("charlie","12345","admin", "donald"):
print("Bienvenido")
print("Adiós")
 La sentencia if-else
• La sentencia if-else ejecutará un bloque de sentencias si su condición es verdadera, u otro bloque si su
condición es falsa.

Ejemplo: Averigüe si un número es par o impar.

n=int(input("Ingrese un numero entero: "))
if n%2==0:
print("El número es par")
else:
print("El número es impar")
print("Fin")
 La sentencia if-else anidada
n=int(input("Ingrese un numero entero: "))
• Para probar más de una condición, se
if n<0:
puede anidar una estructura
if n%2==0:
condicional dentro de otra estructura
print("El número es negativo par")
condicional.
else:
print("El número es negativo impar")
Ejemplo: Averigüe si un número es else:
positivo par, positivo impar, negativo if n>0:
par, negativo impar o cero.
if n % 2 == 0:
print("El número es positivo par")
else:
print("El número es positivo impar")
else:
print("El número es cero")
 La sentencia elif
• Se utiliza también para #Solución #Otra solución
comprobar más condiciones. n=int(input("Ingrese una nota: ")) n=int(input("Ingrese una nota: "))
• A pesar que elif parezca un if if n>=0 and n<=10: if 0<=n<=10:
anidado, elif es una única print("D") print("D")
sentencia. elif n>=11 and n<=14: elif 11<=n<=14:
Ejemplo: Lea una nota n e print("C") print("C")
imprima la letra según el elif n>=15 and n<=17: elif 15<=n<=17:
siguiente cuadro: print("B") print("B")
elif n >= 18 and n <= 20: elif 18<=n <= 20:
print("A") print("A")
else: else:
print("Nota incorrecta") print("Nota incorrecta")
 Estructuras repetitivas
• Mientras que las estructuras condicionales nos permiten ejecutar distintos fragmentos de código
dependiendo de ciertas condiciones, los estructuras repetitivas nos permiten ejecutar un mismo fragmento
de código un cierto número de veces, mientras se cumpla una determinada condición.
• A las estructuras repetitivas también se las conoce como estructuras iterativas, estructuras cíclicas o
simplemente bucles.
• En Python se dispone de dos estructuras cíclicas:
▪ El bucle while
▪ El bucle for-in
 El bucle while
• Este bucle, se encarga de ejecutar una misma acción “mientras que” una determinada condición se cumpla.
Ejemplo 1: Validación de una nota vigesimal. Ingrese la nota de un estudiante y compruebe hasta que sea
valida.
Solución:
nota=int(input("Ingrese una nota: "))
while nota<0 or nota >20:
nota = int(input("Ingrese una nota: "))
print ("la nota es: ",nota)
 El contador
• Un contador es una variable cuyo valor se incrementa o decrementa en una cantidad constante cada vez
que ocurre un evento. Usualmente el contador inicia en 0 o 1.
Ejemplo 2: Escriba un programa que cree un lista de exactamente 5 colores. Si ingresa un color repetido no
lo toma en cuenta.
Solución 1: Solución 2:
c=1 # Contador c c=0 # Contador c
L=[] L=[]
while c<=5: while c<5:
color =input("Ingrese un color: ") color =input("Ingrese un color: ")
if color not in L: if color not in L:
L.append(color) L.append(color)
c=c+1 # usualmente va al final c=c+1 # usualmente va al final
print ("La Lista final es: ",L) print ("La Lista final es: ",L)
 El acumulador
• Un acumulador es un variable que se utiliza para sumar los valores de otra variable una cierta cantidad de
veces. Usualmente el acumulador inicia en 0.
Ejemplo 3: Escriba un programa que solicite cuantas notas tiene un estudiante y calcule su promedio.
Solución:
n=int(input("Ingrese la cantidad de notas: "))
c=0 #Contador c
s=0 #Acumulador s
while c<n:
nota =int(input("Ingrese la nota: "))
s=s+nota
c=c+1
prom=s/n
print ("El promedio es: ",prom)
 La sentencia break
• La sentencia break detiene y sale del bucle.
Ejemplo 4: Escriba un programa que lea nombres hasta que escriba “salir”.
Solución 1: Sin break
nombre=""
while nombre!="salir":
nombre=input("Escriba un nombre: ")
print ("FIN")
Solución 2: Con break
while True:
nombre=input("Escriba un nombre: ")
if nombre=="salir":
break
print ("FIN")
 La sentencia continue
• La sentencia continue se salta el resto del ciclo del bucle y va al siguiente ciclo.
Ejemplo 5: Escriba un programa que imprima los múltiplos de 7 del 1 al 50, excepto el 21.
Solución 1: Sin continue
Solución 2: Con continue
n=1
n=1
while n<=50:
while n<=50:
if n%7==0:
if n%7==0:
if n!=21:
if n==21:
print(n) n=n+1
n=n+1 continue
print("FIN") print(n)
n=n+1
print("FIN")
 El bucle for-in
• El bucle for-in, en Python, es aquel que nos permitirá iterar sobre una variable compleja, del tipo lista, tupla
o rango:
Ejemplo 6: Cree un programa que imprima la siguiente lista de nombres.
L = ["Juan","Rosa","Pablo","Guadalupe","Benito","Pamela"]
Solución 1:
L = ["Juan","Rosa","Pablo","Guadalupe","Benito","Pamela"]
for nombre in L:
print (nombre)
Solución 2:
L = ["Juan","Rosa","Pablo","Guadalupe","Benito","Pamela"]
for i in range(len(L)):
print (L[i])
 Ejemplo
• Utilizando el bucle for-in, imprima la tabla de multiplicar del 1 a 5, hasta el 9.

Solución:
for i in range(1,10):
for j in range(1,6):
print (i," x ",j," = ", i*j)
print("-----------------")
 Ejemplo
• Utilizando el bucle for-in, imprima todos los números primos hasta n.
Nota: En matemáticas, un número primo es un número natural mayor que 1 que tiene únicamente dos
divisores positivos distintos: él mismo y el 1.
Solución:
n=int(input("Ingrese un número entero: "))
for x in range(2,n+1):
#Comprobar si n es primo
flagPrimo=True
for d in range(2,x):
if x%d==0:
flagPrimo = False
break
if flagPrimo:
print("Es primo: ",x)
 Contenido Clase 03
• Definición de función
• Funciones predefinidas
• Funciones definidas en módulos
• Funciones definidas por el usuario
• Funciones sin parámetros que no devuelven valor
• Funciones con parámetros que no devuelven valor
• Funciones anidadas
• Parámetros por omisión
• Funciones que devuelven un valor
• Funciones lambda
 Definición de función
• Una función es una porción de código que realiza
una tarea de forma independiente al resto del
programa.
• Las funciones usualmente reciben datos para
procesar (parámetros de entrada) y devuelven un
resultado (valor de retorno)
• Se puede considerar a la función como un
miniprograma que trabaja dentro de otro
programa.
• Existen funciones que ya viene predefinidas en el
lenguaje, sin embargo nosotros también podemos
crear nuestras propias funciones.
 Funciones predefinidas
• Python proporciona funciones que podemos utilizar directamente.
• abs: valor absoluto. Calcula el valor absoluto de un número.
abs(-3.98) # 3.98
• float: conversión a flotante. Si recibe un número entero como argumento, devuelve el mismo número
convertido en un flotante equivalente. También acepta argumentos de tipo cadena.
float(3) # 3.0
float("3.27") # 3.27
float("2.5e3") # 2500.0 Nota: 2.5e3 equivale a 2.5 × 103
 Funciones predefinidas
• int: conversión a entero. Si recibe un número flotante como argumento, devuelve el entero que se obtiene
eliminando la parte fraccionaria. También acepta como argumento una cadena con forma de entero:
int(2.1) # 2
int(-2.97) # -2
int("2") # 2
int("2.15") # Devuelve un Error
• str: conversión a cadena. Recibe un número y devuelve una representación de éste como cadena.
str(2.15) # "2.15"
str(2.5e-3) # "0.0025"
 Funciones predefinidas
• round: redondeo. Puede usarse con uno o dos argumentos. Si se usa con un sólo argumento, redondea a
cero decimales.
round(2.18) #2
round(-2.94) # -3
round(2.6371,2) # 2.64
round(2.6371,3) # 2.637
Ejemplos:
float("2.5"+"7") # 2.57
abs(-23) % int(7.9) #2
abs(round(-34.2765,1)) # 34.3
float(str(2) * 3 + ".123"+"320")+8.5 # 230.62332
 redondeo
• En Python 3.x, round() se comporta de la siguiente manera:
• Si la cifra que queda es par se deja como tal.
• Si la cifra que queda es impar se debe incrementar en 1.
Este tipo de redondeo es también conocido como el redondeo del banquero. Por ejemplo:
round(3.5) # Devuelve : 4
round(2.5) # Devuelve : 2
round(-2.5) # Devuelve : -2
round(-3.5) # Devuelve : -4
 Funciones predefinidas
• min: halla el mínimo. Devuelve el mínimo de un conjunto de números, cadenas, listas, etc.
min(7.8,5,9.5,6) # 5
min("mandarina","cereza","manzana","fresa") # "cereza"
min("34256") # "2"
• max: halla el máximo. Devuelve el máximo de un conjunto de números, cadenas, listas, etc.
max(7.8,5,9.5,6) # 9.5
max("mandarina","cereza","manzana","fresa") # "manzana"
max("Bienvenidos a Python") # "y"
 Funciones predefinidas
• pow: potencia. Eleva un número a la potencia indicada.
pow(3,4) # 81
pow(7.5,0.25) # 1.6548754598234365

• eval: evaluar. Evalúa una cadena como una expresión matemática.

numero = 7
x=eval("numero * 10 - 20")
print(x) # 50
 Funciones predefinidas
• upper: convierte a mayúsculas.
• lower: convierte a minúsculas.
• len: longitud de una cadena. Devuelve el número de caracteres de una cadena.

cadena= "hoLa munDo"

x=cadena.upper()
y=cadena.lower()
z=len(cadena)
print(x) # "HOLA MUNDO"
print(y) # "hola mundo"
print(z) # 10
 Funciones definidas en módulos
• Python también proporciona funciones especializadas almacenadas en módulos.
• Un módulo es un archivo que contiene variables y funciones ya programadas en Python.
• Mencionemos algunos:
o random: Generar números seudoaleatorios.
o tkinter: Desarrollo de una interfaz gráfica de usuario.
o datetime: Manipulación de fecha y hora.
o math: Funciones matemáticas.
o pickle: Serialización de objetos.
o copy: Duplicar objetos.
o os: Acceso a funciones del sistema operativo.
o shutil: Operaciones de archivos.
 Funciones definidas en módulos
• Por ejemplo, revisemos el módulo math.
• Mediante la sentencia import math podemos anexar sus funciones a nuestro programa.
• Algunas funciones del módulo math:

Ejemplo:
import math
x=math.sin(45*3.1416/180)
print (x)
y=math.ceil(6.0234)
print(y)
z=math.log(123)/math.log(5) #Logaritmo de 123 en base 5
print(z)
 Funciones definidas en módulos
• En el módulo matemático se definen, además, algunas constantes de interés:
print (math.pi) # 3.141592653589793
print (math.e) # 2.718281828459045
• Si no desea hacer referencia al módulo math y acceder
directamente a la función debe declarar:
from math import *
En vez de:
import math
Ejemplo: Se desea calcular el área del siguiente triángulo
rectángulo, teniendo como datos la hipotenusa h y el ángulo α.
Muestre el área con una precisión de 2 decimales.
Nota: El ángulo α es ingresado en sexagesimales y h en metros.
 Solución
import math
h=float(input("Ingrese la hipotenusa: "))
alfa=float(input("Ingrese un ángulo agudo en sexagesimales: "))
cateto1=h*math.cos(alfa*math.pi/180)
cateto2=h*math.sin(alfa*math.pi/180)
area=round(cateto1*cateto2/2,2)
print ("El área es: ",area)

from math import *

h=float(input("Ingrese la hipotenusa: "))
alfa=float(input("Ingrese un ángulo agudo en sexagesimales: "))
cateto1=h*cos(alfa*pi/180)
cateto2=h*sin(alfa*pi/180)
area=round(cateto1*cateto2/2,2)
print ("El área es: ",area)
 Funciones definidas por el usuario
• Hasta ahora sólo hemos usado las funciones que vienen incluidas con Python, pero también es posible
crear nuestras propias funciones.
• La creación de nuevas funciones para resolver problemas particulares es una de las cosas más útiles de los
lenguajes de programación.
• Una función es un conjunto de sentencias que pueden ser invocadas varias veces durante la ejecución de
un programa. Las ventajas de su uso son, la minimización de código, el aumento de la legibilidad y la
fomentación de la reutilización de código.
• Podemos crear 4 tipos de funciones:
1. Funciones sin parámetros que no devuelven valor.
2. Funciones con parámetros que no devuelven valor.
3. Funciones sin parámetros que si devuelven valor.
4. Funciones con parámetros que si devuelven valor.
 Funciones sin parámetros que no devuelven valor
• En Python, la definición de funciones se realiza mediante la instrucción def más un nombre de función
descriptivo, seguido de paréntesis de apertura y cierre (o sea sin parámetros). La definición de la función
finaliza con dos puntos (:) y el algoritmo que la compone irá indentado con 4 espacios (una tabulación).
def mi_funcion():
# aquí el algoritmo
• Una función, no es ejecutada hasta que no sea invocada. Para invocar una función, simplemente se la llama
por su nombre:
def mi_funcion():
print ("Hola Mundo")
#Programa principal
mi_funcion() #Llamada a la función
 Funciones con parámetros que no devuelven valor
• Un parámetro es un valor que la función espera recibir cuando es llamada (invocada) a fin de
ejecutar acciones en base al mismo. Si la función recibe varios parámetros, estas irán separados
por una coma.
Ejemplo:
def repetir(nombre, n):
L=len(nombre)
print("El nombre tiene ",L," caracteres")
print("repitiendo {0} veces".format(n))
print(n*nombre)
#Programa principal
repetir("Juan", 3)
 Ejemplo
• Escriba dos funciones, una que calcule el área de un
#Programa principal (main)
rectángulo y otra que triplique una palabra. El usuario
ingresa la base, altura y la palabra. print ("Área de un rectángulo")
Solución: a=float(input ("Ingrese lado a: "))
def areaR(a,b): b=float(input ("Ingrese lado b: "))
area=a*b areaR(a,b)
print("El área es: ", area)
print ("Triplicando palabra")
def palabraTri(palabra): pal=input ("Escriba una palabra: ")
print(3*palabra) palabraTri(pal)
 Funciones anidadas
• Python ofrece la posibilidad de crear funciones anidadas. Una función anidada es una función que se crea
en el cuerpo de otra función que se conoce como externa.
Ejemplo: Escriba un programa que halle el volumen de dos edificios de forma de pirámide y prisma
rectangular como muestra la figura. Como dato tenemos que ambos tiene el mismo largo, ancho y altura.
Cree una función que reciba los 3 parámetros y dentro de ella dos funciones anidadas, una que calcule el
volumen de la pirámide y otra que calcule el volumen del prisma rectangular. La función muestra
ambos resultados.
Dato:
 Solución
def volumenes(a,b,h): #Programa principal (main)
def piramide(): a=float(input("Lado a: "))
vpi=a*b*h/3 b=float(input("Lado b: "))
print("Volumen pirámide: {0} m3".format(vpi)) h=float(input("Altura h: "))
def prisma(): volumenes(a,b,h)
vpa=a*b*h
print("Volumen prisma rectangular: ",vpa," m3")
piramide()
prisma()
 Parámetros por omisión
• En Python, también es posible, asignar valores por defecto a los parámetros de las funciones.
• Esto significa, que la función podrá ser llamada con menos argumentos de los que espera y reemplazar los
valores que no se le envía por los de omisión.
Ejemplo: En una tienda se esta ofreciendo un descuento del 20% en productos seleccionados y además a
algunos clientes se les esta obsequiando al azar un USB.
Escriba una función que permita ingresar el valor de la compra y manejar todas las combinaciones posibles
mostrando en pantalla el resultado.
La función solo debe tener dos líneas, una para calcular y otra para imprimir.
Las combinaciones posibles son:
Sin descuento con obsequio
Con descuento con obsequio
Sin descuento sin obsequio
Con descuento sin obsequio
 Funciones que devuelven un valor
• Hasta ahora la función es la que ha estado mostrando el resultado. La función también puede devolver el
resultado a la sentencia que la invoca. Esto se logra utilizando la sentencia return.
Ejemplo: Cree su propia función matemática que calcule el interés simple.
La función devuelve el resultado a la sentencia que la invoca.
El programa solicita el capital inicial C, la tasa de interés anual i,
el tiempo t en meses y devuelve el monto final a pagar.
Ejemplo de un caso: Una pequeña empresa, necesita pedir un prestamo
para poder pagar un pedido a un proveedor, así que pide a una caja
popular un préstamo de 50 mil soles a pagar en 3 meses con una tasa
del 18% anual. ¿Cuál es el pago total final a la caja?
I = (50 000) (0.18) (3/12)
I = 2 250
T = 50 000 + 2 250 = 52 250 soles
 Solución
def calcular(valor, desc=0, obsequio="USB"):
res=valor*(1-desc)
print (res, obsequio)
#Programa principal (main)
v=float(input("Ingrese el valor de la compra: "))
print("Sin descuento con obsequio")
calcular(v)
print("Con descuento con obsequio")
calcular(v,0.2)
print("Sin descuento sin obsequio")
calcular(v,0,"")
print("Con descuento sin obsequio")
calcular(v,0.2,"")
 Solución
def int_simple(C, i, t):
I=C*i*t
return I
#Programa principal (main)
C=float(input("Ingrese el monto del préstamo: "))
i=float(input("Ingrese la tasa de interés anual: "))
t=int(input("Ingrese los meses para pagar: "))
total=C+int_simple(C,i,t/12)
print("El pago total es: ",total)
 Funciones anónimas
• Se denominan anónimas porque no se crea mediante la instrucción def, es decir no tienen un nombre
asociado.
• Estas funciones constan de una sola expresión y normalmente se le asigna a una variable.
• Para crearlas se utiliza el operador lambda.
Ejemplo:
triangulo=lambda x,y : x*y/2
area=triangulo(3,4)
print(area) # Imprime 6.0
division=lambda x,y : x/y if y!=0 else "No se puede"
resultado1=division(3,4)
print(resultado1) # Imprime 0.75
resultado2=division(3,0)
print(resultado2) # No se puede
 Variables locales y globales
• Variables locales: Son aquellas que se declaran dentro de una función y solo existen dentro de esa función.
Es decir que fuera de la función la variable es desconocida y no se puede acceder a ella.
• Variables globales: Son aquellas que se declaran en el cuerpo principal del programa y pueden ser utilizadas
por todo el programa. Es decir que cualquier función puede acceder a su valor.
 Ejemplo
def f(): #Programa principal
y=6 #Variable local de f x=5 #Variable global
#accesible para lectura en g y h #accesible para lectura en todo el programa
print("x y: ",x,y) print("x: ",x)
def g(): f()
z=7 #Variable local de g Que devuelve el siguiente resultado:
print("x y z: ",x,y,z) x: 5
def h(): x y: 5 6
w=8 #Variable local de h x y z: 5 6 7
print("x y w: ",x,y,z) x y w: 5 6 8
g()
h()
 Modificar una variable global desde una función
• Una variable global no se puede modificar directamente desde una función.
Ejemplo:
Ejemplo:
def f():
def f(x):
x=7 #Variable local de x
x=7 #Variable local de x
print("x de f= ",x)
print("x de f= ",x)

#Programa principal
x=5 #Variable global #Programa principal
print("x del principal= ",x) # 5 x=5 #Variable global
f() #7 print("x del principal= ",x) # 5
print("x del principal= ",x) # 5 f(x) #7
print("x del principal= ",x) # 5
 Modificar una variable global desde una función
• Para poder modificarlo debemos utilizar la palabra clave global.
Ejemplo:
def f():
global x
x=7 #Modifica la variable global
print("x de f= ",x)

#Programa principal
x=5 #Variable global
print("x del principal= ",x) # 5
f() #7
print("x del principal= ",x) # 7
 Contenido Clase 04
• Listas
• Accediendo a los elementos de una lista
• Acceder al contenido de una lista dentro de una lista
• Eliminado elementos de una lista
• Agregar elementos a la lista
• Cambiando un elemento de la lista
• Ejercicios
 Listas
• Una lista es un conjunto ordenado de valores, en el cual cada valor se identifica mediante un índice. Los
valores que constituyen una lista son sus elementos.
• Las listas son similares al array dinámico empleado en otros lenguajes de programación.
• Para definir una lista se utilizan corchetes ([]) entre los cuales pueden aparecer diferentes valores
separados por comas.
Ejemplo:
lista = [] # Lista vacía
miLista = [2, "hola" , True, 4.5, ["siete",7,4+5j], 1/3]
• Para crear una lista a partir de una cadena se utiliza la función list.
Ejemplo:
letras=list("murciélago") # ['m', 'u', 'r', 'c', 'i', 'é', 'l', 'a', 'g', 'o']
digitos=list(str(12345.678)) # ['1', '2', '3', '4', '5', '.', '6', '7', '8']
 Accediendo a los elementos de una lista
• Acceder a un elemento de una lista. Cada elemento se identifica mediante un índice, el primer elemento
tiene índice 0.
• También se puede acceder a los elementos de una lista en orden inverso (derecha a izquierda), indicando
como índice un número negativo. Donde el último elemento tiene el índice -1, el penúltimo -2 y así
sucesivamente.
Ejemplo:
lista=[4,7,9,2,3,1,8,5]
s=lista[0]+lista[3] # 4+2 0 1 2 3 4 5 6 7
print(s) # Imprime 6 [ 4, 7, 9, 2, 3, 1, 8, 5 ]
s=lista[-1]+lista[-4] # 5+3 -8 -7 -6 -5 -4 -3 -2 -1
print(s) # Imprime 8
 Accediendo a los elementos de una lista
• También se puede acceder a un fragmento de la lista original usando el signo de los dos puntos (:) para
indicar los índices inicio y final.
• Esto retornara una sublista que inicie con el elemento del primer subíndice indicado y termine con el
elemento que está un índice anterior al segundo índice indicado.
Ejemplo:
lista=[4,7,9,2,3,1,8,5]
lista1=lista[2:5] 0 1 2 3 4 5 6 7
print(lista1) #Imprime [9, 2, 3] [ 4, 7, 9, 2, 3, 1, 8, 5 ]
lista2=lista[-6:-3]
-8 -7 -6 -5 -4 -3 -2 -1
print(lista2) #Imprime [9, 2, 3]
lista3=lista[2:-3]
print(lista3) #Imprime [9, 2, 3]
lista4=lista[-6:5]
print(lista4) #Imprime [9, 2, 3]
 Accediendo a los elementos de una lista
• Si se omite el primer índice se asume desde el primer elemento. Y si se omite el segundo tomará hasta el
último elemento inclusive. Si se omite ambos, será una copia del original.
Ejemplo:
lista=[4,7,9,2,3,1,8,5]
lista1=lista[:5] 0 1 2 3 4 5 6 7
print(lista1) #Imprime [4, 7, 9, 2, 3] [ 4, 7, 9, 2, 3, 1, 8, 5 ]
lista2=lista[5:]
-8 -7 -6 -5 -4 -3 -2 -1
print(lista2) #Imprime [1, 8, 5]
lista3=lista[:-5]
print(lista3) #Imprime [4, 7, 9]
lista4=lista[-5:]
print(lista4) #Imprime [2, 3, 1, 8, 5]
lista5=lista[:]
print(lista5) #Imprime [4,7,9,2,3,1,8,5]
 Accediendo a los elementos de una lista
• Puede añadir un tercer número, también separado por dos puntos (:), para que nos retorne los elementos
del rango indicado con un cierto paso o salto (step).
Ejemplo: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
[ 4, 10, 7, 15, 9, 11, 2, 3, 6, 13, 1, 8, 14, 5, 0, 12 ]
-16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
lista=[4,10,7,15,9,11,2,3,6,13,1,8,14,5,0,12]
lista1=lista[4:12]
print(lista1) #Imprime [9, 11, 2, 3, 6, 13, 1, 8]
lista2=lista[4:12:2]
print(lista2) #Imprime [9, 2, 6, 1]
lista3=lista[-12:-4]
print(lista3) #Imprime [9, 11, 2, 3, 6, 13, 1, 8]
lista4=lista[-12:-4:2]
print(lista4) #Imprime [9, 2, 6, 1]
 Accediendo a los elementos de una lista
• Cuando el salto es negativo, no funciona cuando se indica un rango, pero si se indica toda la lista el
recorrido es al revés (derecha a izquierda).
Ejemplo: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
[ 4, 10, 7, 15, 9, 11, 2, 3, 6, 13, 1, 8, 14, 5, 0, 12 ]
-16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
lista=[4,10,7,15,9,11,2,3,6,13,1,8,14,5,0,12]
lista1=lista[4:12]
print(lista1) #Imprime [9, 11, 2, 3, 6, 13, 1, 8]
lista2=lista[4:12:-2]
print(lista2) #Imprime [] No funciona al revés
lista3=lista1[::-2]
print(lista3) #Imprime [8, 13, 3, 11] Si funciona al revés
 Accediendo a los elementos de una lista
• Cuando el salto es negativo, no funciona cuando se indica un rango pero si se indica toda la lista el
recorrido es al revés (derecha a izquierda).
Ejemplo: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
[ 4, 10, 7, 15, 9, 11, 2, 3, 6, 13, 1, 8, 14, 5, 0, 12 ]
-16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
lista=[4,10,7,15,9,11,2,3,6,13,1,8,14,5,0,12]
lista1=lista[-12:-4]
print(lista1) #Imprime [9, 11, 2, 3, 6, 13, 1, 8]
lista2=lista[-12:-4:-2]
print(lista2) #Imprime [] No funciona al revés
lista3=lista1[::-2]
print(lista3) #Imprime [8, 13, 3, 11] Si funciona al revés
 Acceder al contenido de una lista dentro de una lista
• Una lista puede contener datos de todo tipo, lo que incluye cadenas, números y hasta otras listas.
• Para acceder al contenido de una lista dentro de otra, se pone un índice a continuación del otro: primero el
de la lista inicial, segundo de la lista contenida en esta y así sucesivamente.
Ejemplo:
lista=[5,["hola","mundo","hello","world"],7.8,[2,[3,4,5,6],7],"hi"]
x=lista[2]
print(x) #Imprime 7.8
y=lista[1]
print(y) #Imprime ["hola","mundo","hello","world"]
z=lista[1][2]
print(z) #Imprime hello
w=lista[3][1][2]
print(w) #Imprime 5
 Eliminado elementos de una lista
• Para eliminar un elemento de una lista mediante su índice se utiliza la instrucción del.
Ejemplo:
lista=[5,["hola","mundo","hello","world"],7.8,[2,[3,4,5,6],7],"hi",1/5]
print(lista) #Imprime [5, ['hola', 'mundo', 'hello', 'world'], 7.8, [2, [3, 4, 5, 6], 7], 'hi', 0.2]
del lista[2]
print(lista) #Imprime [5, ['hola', 'mundo', 'hello', 'world'], [2, [3, 4, 5, 6], 7], 'hi', 0.2]
del lista[1][2]
print(lista) #Imprime [5, ['hola', 'mundo', 'world'], [2, [3, 4, 5, 6], 7], 'hi', 0.2]
del lista[2][1][2]
print(lista) #Imprime [5, ['hola', 'mundo', 'world'], [2, [3, 4, 6], 7], 'hi', 0.2]
del lista [1:4]
print(lista) #Imprime [5, 0.2]
 Eliminado elementos de una lista
• Para eliminar un elemento de una lista mediante su valor se utiliza el método remove().
• Si un elemento aparece repetido en la lista, el método remove() solo borrará la primera ocurrencia que
encuentre en la misma.
• Si el elemento no se encuentra causa un error.
Ejemplo:
lista=[5,["hola","mundo","hello","world"],7.8,[2,[3,4,5,6],7],"hi",1/5]
lista.remove(7.8)
print (lista) #Imprime [5,["hola","mundo","hello","world"],[2,[3,4,5,6],7],"hi",1/5]
lista.remove(["hola","mundo","hello","world"])
print (lista) #Imprime [5, [2, [3, 4, 5, 6], 7], 'hi', 0.2]
lista[1][1].remove(5)
print (lista) #Imprime [5, [2, [3, 4, 6], 7], 'hi', 0.2]
 Eliminado elementos de una lista
• Otro método para eliminar elementos es pop(), que devuelve el elemento borrado y recibe como
argumento el índice del elemento que será eliminado.
• Si no se pasa ningún valor como índice, será el último elemento de la lista el eliminado.
Ejemplo:
lista=[2,4,8,3,5,9,6,7]
x=lista.pop(4)
print (x) #Imprime 5
print (lista) #Imprime [2, 4, 8, 3, 9, 6, 7]
y=lista.pop()
print (y) #Imprime 7
print (lista) #Imprime [2, 4, 8, 3, 9, 6]
 Eliminado elementos de una lista
• Para eliminar todos los elementos de una lista utilice el método clear().
• Otra forma de borrar todos los elementos de una lista es asignándole una lista vacía [].
Ejemplo:
lista1=[2,4,8,3,5,9,6,7]
print (lista1) #Imprime [2, 4, 8, 3, 9, 6, 7]
lista1.clear()
print (lista1) #Imprime []
lista2=[1,2,3,["hola", "mundo"]]
print (lista2) #Imprime [1, 2, 3, ['hola', 'mundo']]
lista2=[]
print (lista2) #Imprime []
 Agregar elementos a la lista
• Para agregar un elemento de una lista se utiliza el método append(). El elemento se
agrega al final de la lista.
Ejemplo:
lista=[6,2,8,0,4]
lista.append(5)
print (lista) #Imprime [6, 2, 8, 0, 4, 5]
lista.append(["a","e","i"])
print (lista) #Imprime [6, 2, 8, 0, 4, 5, ['a', 'e', 'i']]
lista[6].append("o")
print (lista) #Imprime [6, 2, 8, 0, 4, 5, ['a', 'e', 'i', 'o']]
 Agregar elementos a la lista
• Para agregar un elemento de una lista en cualquier lugar, se utiliza el método insert().
Ejemplo:
lista=[6,2,8,0,4]
lista.insert(3,5)
print (lista) #Imprime [6, 2, 8, 5, 0, 4]
lista.insert(0,["a","e","i"])
print (lista) #Imprime [['a', 'e', 'i'], 6, 2, 8, 5, 0, 4]
lista[0].insert(1,"o")
print (lista) #Imprime [['a', 'o', 'e', 'i'], 6, 2, 8, 5, 0, 4]
 Cambiando un elemento de la lista
Ejemplo:
lista=[2,4,8,3,5,9,1,6,0,7]
print (lista)
lista[2]=150
lista[5]="hola"
lista[7]=["a","b","c"]
print (lista) #Imprime [2, 4, 150, 3, 5, 'hola', 1, ['a', 'b', 'c'], 0, 7]
 Conteo e índice de un elemento
• Para obtener el número de ocurrencias de un elemento en una lista utilizamos el método
count().
• Para obtener el índice de un elemento utilizamos el método index(). Si hubiera
repeticiones, devuelve el índice del primero que encuentra. Si el elemento no existe
ocasiona un error.
Ejemplo:
L=[9,4,7,3,4,7,6,7,8,4,3,1,7]
c=L.count(7)
print (c) # devuelve 4
ind=L.index(7)
print (ind) # devuelve 2
 Operadores + y * en listas
• Para concatenar varias listas puede utilizar el operador + (concatenación).
L1=[8,6,4]
L2=[1,2]
L3=[3,4,5]
L4=L1+L2+L3
print (L4) # devuelve [8, 6, 4, 1, 2, 3, 4, 5]
#Tambien puede utilizar el método extend().
L1.extend(L2) # resulta L1= [8, 6, 4, 1, 2]
L1.extend(L3) # resulta L1= [8, 6, 4, 1, 2, 3, 5]
print(L1) # devuelve L1= [8, 6, 4, 1, 2, 3, 5]
• Para repetir una lista puede usar el operador * (repetición).
L1=[8,6,4]
L2=3*L1
print(L2) # devuelve [8, 6, 4, 8, 6, 4, 8, 6, 4]
 Tamaño de una lista
• Tamaño de una lista: Puede obtenerse mediante la función len().
Ejemplo:
L1=[4,2,"hi",True,5+2]
tam=len(L1)
print (tam) # devuelve 5
L2=[]
tam=len(L2)
print (tam) # devuelve 0
 Pertenencia a una lista
• Para saber si un elemento esta en la lista utilizamos el operador in.
• También puede usar el operador not in para averiguar si no está en la lista.
Ejemplo:
L=["i","a","u","e","o"]
resp="e" in L
print(resp) # devuelve True
N=[5,2,8,4,7,3]
resp=6 in N
print(resp) # devuelve False
resp=6 not in N
print(resp) # devuelve True
 Ordenación de una lista de números
• La lista se ordena por defecto de forma ascendente. Mediante el parámetro reverse se puede ordenar
descendentemente.
• Para ordenar puede utilizar el método sort() o la función sorted().
• La diferencia es que sort() altera la lista original.
L=[5,3,8,1,0,6,2,9,7,4]
LA=sorted(L)
print (LA) # devuelve [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print (L) # devuelve [5,3,8,1,0,6,2,9,7,4] No cambia la lista original
LD=sorted(L,reverse=True)
print (LD) # devuelve [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
print (L) # devuelve [5,3,8,1,0,6,2,9,7,4] No cambia la lista original
L.sort()
print(L) # devuelve [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] Cambia la lista original
L.sort(reverse=True)
print(L) # devuelve [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
 Ordenación de una lista de texto
• Por defecto se ordena ascendentemente de acuerdo a su código ANSI.
• Sin embargo se puede pasar un criterio de ordenación por minúsculas o mayúsculas mediante el parámetro key.
L=["Rosa","Maria","juan","Benito","Juan","ana","Lee"]
LA=sorted(L)
print (LA) # devuelve ['Benito', 'Juan', 'Lee', 'Maria', 'Rosa', 'ana', 'juan']
LA=sorted(L,key=str.lower)
print (LA) # devuelve ['ana', 'Benito', 'juan', 'Juan', 'Lee', 'Maria', 'Rosa']
LD=sorted(L,key=str.lower,reverse=True)
print (LD) # devuelve ['Rosa', 'Maria', 'Lee', 'juan', 'Juan', 'Benito', 'ana']
L.sort()
print (L) # devuelve ['Benito', 'Juan', 'Lee', 'Maria', 'Rosa', 'ana', 'juan']
L.sort(key=str. lower)
print (L) # devuelve ['ana', 'Benito', 'Juan', 'juan', 'Lee', 'Maria', 'Rosa']
L.sort(key=str. lower,reverse=True)
print (L) # devuelve ['Rosa', 'Maria', 'Lee', 'Juan', 'juan', 'Benito', 'ana']
 Ordenación de una lista de listas
• Se utiliza la función lambda para elegir respecto a que valor se quiere ordenar. No aplica a sort().
L=[["maria",19],["Rosa",18],["juan",14],["Benito",16],["Juan",17],["ana",18]]
LNota=sorted(L,key=lambda nota:nota[1])
print ("LNota=",LNota) # [['juan', 14], ['Benito', 16], ['Juan', 17], ['Rosa', 18], ['ana', 18], ['maria', 19]]
LNotaD=sorted(L,key=lambda nota:nota[1],reverse=True)
print ("LNotaD=",LNotaD) # [['maria', 19], ['Rosa', 18], ['ana', 18], ['Juan', 17], ['Benito', 16], ['juan', 14]]
LNombre=sorted(L,key=lambda nombre:nombre[0])
print ("LNombre=",LNombre) # [['Benito', 16], ['Juan', 17], ['Rosa', 18], ['ana', 18], ['juan', 14], ['maria', 19]]
LNombreA=sorted(L,key=lambda nombre:nombre[0].lower())
print ("LNombreA=",LNombreA) # [['ana', 18], ['Benito', 16], ['juan', 14], ['Juan', 17], ['maria', 19], ['Rosa', 18]]
LNombreD=sorted(L,key=lambda nombre:nombre[0].lower(),reverse=True)
print ("LNombreD=",LNombreD) # [['Rosa', 18], ['maria', 19], ['juan', 14], ['Juan', 17], ['Benito', 16], ['ana', 18]]
 Orden inverso de una lista
• Para mostrar una lista en orden inverso, utilizamos el método reverse().
• El método reverse() altera la lista original.
Ejemplo:
L=["Rosa","Maria","juan","Benito","Juan","ana","Lee"]
L.reverse()
print(L) # ['Lee', 'ana', 'Juan', 'Benito', 'juan', 'Maria', 'Rosa']
N=[5,2,8,4,7,3]
N.reverse()
print(N) # [3, 7, 4, 8, 2, 5]
L=[["maria",19],["Rosa",18],["juan",14],["Benito",16],["Juan",17],["ana",18]]
L.reverse()
print(L) # [['ana', 18], ['Juan', 17], ['Benito', 16], ['juan', 14], ['Rosa', 18], ['maria', 19]]
 Copiar o clonar una lista
• Cuando se tiene una lista L y se quiere copiar a la lista C mediante la expresión C = L, lo
que se hace en realidad es que ambas variables apunten a la misma dirección de
memoria, se dice que solo pasa la referencia, es decir que L y C son alias de la misma lista.
Y cualquier modificación de una ellas afectara por igual a la otra.
Ejemplo:
L=[4,2,["a","e"],6]
C=L
del L[2]
print (L) # devuelve [4, 2, 6]
print (C) # devuelve [4, 2, 6]
 Copiar o clonar una lista
• Si queremos hacer una copia independiente, en otra dirección de memoria, tenemos que usar la
expresión C = L[:]
L=[4,2,["a","e"],6]
C=L[:]
del L[2]
print (L) # devuelve [4, 2, 6]
print (C) # devuelve [4, 2, ['a', 'e'], 6]
• También puede usar en método copy().
L=[4,2,["a","e"],6]
C=L.copy()
del L[2]
print (L) # devuelve [4, 2, 6]
print (C) # devuelve [4, 2, ['a', 'e'], 6]
 Pasar una lista como parámetro a una función
• Cuando se pasa una lista como argumento, en realidad se pasa una referencia a ella, no una copia de la lista.
Ejemplo: Se muestra como una lista se pasa como referencia (el original) y un entero se pasa como valor (la copia).
def eliminarMaximo(lista,x):
lista.remove(max(lista))
print("Imprimiendo desde la función")
print(L)
x=50
print(x)
#Programa principal
L=[4,2,8,6,7] # mutable pasa como referencia
x=100 # inmutable pasa como valor
print("Imprimiendo desde el programa principal (antes)")
print(L)
print(x)
eliminarMaximo(L,x)
print("Imprimiendo desde el programa principal(después)")
print(L)
print(x)
 La función range()
• La función range() crea una progresión aritmética de números enteros.
• Su sintaxis es: range(inicio,fin,incremento)
• Si no se indica el inicio, asume que es 0. Si no se indica el incremento asume que es 1.
• El parámetro fin es obligatorio.
• Al igual que las listas el rango generado no toma en cuenta el último elemento del rango.
Ejemplo:
x=range(10)
y=range(3,10)
z=range(4,10,2)
w=range(10,4,-2)
print (list(x)) # devuelve [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print (list(y)) # devuelve [3, 4, 5, 6, 7, 8, 9]
print (list(z)) # devuelve [4, 6, 8]
print (list(w)) # devuelve [10, 8, 6]
 Crear una lista mediante un rango
• Para crear una lista de enteros en progresión aritmética mediante un rango
utilice la función range() y luego la función list().

L1=list(range(-5,5,2))
L2=list(range(0))
print(L1) # devuelve [-5, -3, -1, 1, 3]
print(L2) # devuelve []
 Crear una lista por comprensión
• Así como en matemáticas se pueden definir los conjuntos por extensión y
por comprensión, en Python se pueden definir las listas también por
extensión y por comprensión.
Ejemplo: Por extensión
L1=[1,4,9,16,25,36,49,64,81,100]
print(L1) # devuelve [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Ejemplo: Por comprensión
L2=[x**2 for x in range(1,11)]
print(L2) # devuelve [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 Crear una lista por comprensión
• Ejemplo: Cree por comprensión una lista formada por las mayúsculas de una frase.
Solución:
F=input("Escriba una frase: ")
L=[x for x in F if x>="A" and x<="Z"]
print (L)
• Ejemplo: Genere la siguiente lista por comprensión [0, 4, 16, 36, 64, 100]
Solución: Mostremos 3 soluciones posibles.
L1 = [x**2 for x in range(0,12,2)]
print(L1) # devuelve [0, 4, 16, 36, 64, 100]
L2 = [x**2 for x in range(11) if x % 2 == 0]
print(L2) # devuelve [0, 4, 16, 36, 64, 100]
L3 = [x**2 for x in [0,2,4,6,8,10]]
print(L3) # devuelve [0, 4, 16, 36, 64, 100]
 Crear una lista por comprensión
• Ejemplo: Cree por comprensión una lista que muestre la tabla de multiplicar del 1 al 9.
Solución:
L= [x*y for x in range(1,10) for y in range (1,10)]
print(L)
• Ejemplo: Cree por comprensión una lista de listas de la forma [x, y, z] entre 1 y 100, donde
la suma de los cuadrados de los dos primeros es igual al cuadrado del tercero.
Solución:
L = [[x,y,z] for x in range(1,101) for y in range (1,101) for z in range (1,101) if
x**2+y**2==z**2]
print(L)
 Inicialización de múltiples variables
• Utilizando listas podemos inicializar rápidamente un conjunto de variables
[a,b,c]=[10,20,30]
print(a) # devuelve 10
print(b) # devuelve 20
print(c) # devuelve 30
s=a+b+c
print (s) # devuelve 60
• Una operación común en programación es intercambiar (swap) los valores de dos variables.
a=7
b=5
[a,b]=[b,a]
print ("a= ", a) # devuelve 5
print ("b= ", b) # devuelve 7
 Contenido Clase 05
• Tuplas
• Convertir lista a tupla y viceversa
• Diccionarios
• Obtener listas de claves y valores
• Añadir y eliminar un elemento
• Creación de un diccionario por comprensión
• Ordenar un diccionario
• Convertir una lista a diccionario
• Números aleatorios entre dos números
• Números aleatorios de una secuencia
 Tuplas
• Una tupla es similar a una lista salvo en que es inmutable (no puede modificarse una vez creada).
• Una tupla es una colección de valores separados por comas que pueden ser números, cadenas, tuplas, listas, etc.
• También puede crear la tupla usando paréntesis, así una tupla vacía se escribe así ().
diasLab = "lun", "mar", "mie", "jue", "vie"
print(diasLab) # devuelve ('lun', 'mar', 'mie', 'jue', 'vie')
print (diasLab[3]) # devuelve jue
print (diasLab[-3]) # devuelve mie
#diasLab[3]="dom" # No se puede modificar una tupla
diasImp=diasLab[::2]
print (diasImp) # devuelve ('lun', 'mie', 'vie')
igv = 0.18, # crea una tupla de un solo elemento, también pudo escribir igv=(0.18)
print (igv) # devuelve (0.18,)
valor=100
precio=valor+valor*igv[0]
print(precio) # devuelve 118.0
Lista=sorted(diasLab) # Ordena y construye una lista a partir de la tupla. El método sort() causa un error
print(Lista) # devuelve ['jue', 'lun', 'mar', 'mie', 'vie']
 Ejemplos de tuplas
T=1,2,3,(10,20,"hola"),5,6
print(T[3][2]) # devuelve hola
a=7
b=5
a,b=b,a
print("a= ",a) # devuelve 5
print("b= ",b) # devuelve 7
T1=("ta","ta")*3
print (T1) # devuelve ('ta', 'ta', 'ta', 'ta', 'ta', 'ta')
c=T.index(5)
print(c) # devuelve 4
T2=T+T1
print(T2) # devuelve (1, 2, 3, (10, 20, 'hola'), 5, 6, 'ta', 'ta', 'ta', 'ta', 'ta', 'ta’)
#del T2[2] # No se puede modificar una tupla
 Convertir lista en tupla y viceversa
• Para convertir una lista en tupla utilizamos la función tuple().
• Para convertir una tupla en lista utilizamos la función list().
Lista=[1,2,"a","b"]
Tupla=3,4,"c","d"
print(Lista) # devuelve [1, 2, 'a', 'b']
print(Tupla) # devuelve (3, 4, 'c', 'd')
L=list(Tupla)
T=tuple(Lista)
print(L) # devuelve [3, 4, 'c', 'd']
print(T) # devuelve (1, 2, 'a', 'b')
 Diccionarios
• Un diccionario es una colección de elementos emparejados clave:valor, que utiliza el valor clave como índice para
acceder al valor valor. Los diccionarios son mutables.
• La clave debe ser única, es decir que no puede haber dos valores diferentes con la misma clave. Si se ingresa un
nuevo elemento con la misma clave, no resulta un error, sino queda solo este último.
• La clave puede ser número, cadena o tupla, no lista. El valor puede ser de cualquier tipo.
• Para declarar un diccionario en Python se utilizan las llaves {} entre las que se encuentran los pares clave:valor
separados por comas. La clave de cada elemento aparece separada del correspondiente valor por dos puntos.
Ejemplo:
D={"danza":"baile","novicio":["inexperto","nuevo","novato"],("fácil","poderoso","grandioso"):"Python"}
print(D) # {'danza': 'baile', 'novicio': ['inexperto', 'nuevo', 'novato'], ('fácil', 'poderoso', 'grandioso'): 'Python'}
print(D["novicio"]) # ['inexperto', 'nuevo', 'novato']
D["novicio"]=D["novicio"]+["noob"]
print(D) #{'danza': 'baile', 'novicio': ['inexperto', 'nuevo', 'novato', 'noob'], ('fácil', 'poderoso', 'grandioso'): 'Python'}
print(D[("fácil","poderoso","grandioso")]) #Python
 Ejemplo
D={}
print (D) # Devuelve {} Diccionario vacio
D1 = {"Juan":16, "Rosa":18, "Federico":20, "Guadalupe":None,"Benito":12, "Ana":17}
print (D1) # {'Juan': 16, 'Rosa': 18, 'Federico': 20, 'Guadalupe': None, 'Benito': 12, 'Ana': 17}
tam=len(D1)
print (tam) # Devuelve 6
print(D1["Rosa"]) # Devuelve 18
D1["Benito"]=15
D1["Guadalupe"]=14
print (D1) # Devuelve {'Juan': 16, 'Rosa': 18, 'Federico': 20, 'Guadalupe': 14, 'Benito': 15, 'Ana': 17}
T={(1,2,3):"1er trim",(4,5,6):"2do trim",(7,8,9):"3er trim",(10,11,12):"4to trim"}
T2=T[(4,5,6)]
print (T2) # Devuelve 2do trim
x="Rosa" in D1 # Solo pertenencia con la clave y no con el valor
print(x) # Devuelve True
 Obtener lista de claves y valores
• Para obtener la lista de claves usamos el método keys().
• Para obtener la lista de valores usamos el método values().
• Para obtener una lista de tuplas con los elementos del diccionario usamos el método items().
Ejemplo:
D={7:"siete",5:"cinco",9:"nueve",3:"tres",1:"uno",6:"seis"}
Claves=list(D.keys())
print(Claves) # [7, 5, 9, 3, 1, 6]
Valores=list(D.values())
print(Valores) # ['siete', 'cinco', 'nueve', 'tres', 'uno', 'seis']
Elementos=list(D.items())
print(Elementos) # [(7, 'siete'), (5, 'cinco'), (9, 'nueve'), (3, 'tres'), (1, 'uno'), (6, 'seis')]
Elementos=[list(Elementos[i]) for i in range(len(Elementos))] # Otra forma Elementos=[list(x) for x in Elementos]
print(Elementos) #[[7, 'siete'], [5, 'cinco'], [9, 'nueve'], [3, 'tres'], [1, 'uno'], [6, 'seis']]
 Añadir y eliminar un elemento
• Añadir un elemento es exactamente igual a modificar uno ya existente, ya que si la
clave no existe, automáticamente Python lo añadirá con su correspondiente valor.
• La función del() elimina un elemento del diccionario, para ello debe indicar
solamente su clave.
• El método pop() también funciona en los diccionarios. Se le pasa la clave y
devuelve el valor.
• El método popitem() elimina el elemento que esta al último en el diccionario y
devuelve la tupla (clave, valor).
• Para eliminar todos los elementos en el diccionario y dejarlo vacío puede usar el
método clear().
 Ejemplo
D={2:"dos",4:"cuatro",6:"seis",10:"diez",12:"doce"}
print (D) # {2: 'dos', 4: 'cuatro', 6: 'seis', 10: 'diez', 12: 'doce'}
D[8]="ocho"
print (D) # {2: 'dos', 4: 'cuatro', 6: 'seis', 10: 'diez', 12: 'doce', 8: 'ocho'}
del(D[6])
print (D) # {2: 'dos', 4: 'cuatro', 10: 'diez', 12: 'doce', 8: 'ocho'}
x=D.pop(10)
print (x) # diez
print (D) # {2: 'dos', 4: 'cuatro', 12: 'doce', 8: 'ocho’}
x=D.popitem()
print(x) # (8, 'ocho')
x=D.popitem()
print(x) # (12, 'doce')
print(D) # {2: 'dos', 4: 'cuatro'}
 Ordenar un diccionario
• A diferencia de las listas, los diccionarios no tienen el método sort(), pero sí
que podemos utilizar la función sorted() para obtener una lista ordenada de
las claves.
• Para ordenar los elementos utilice el método items() en sorted(). Utiliza
como criterio de ordenación a la clave.
• Si desea utilizar el valor como criterio de ordenación para ordenar los
elementos, primero debe importar el módulo operator y utilizar el método
itemgetter(1). Puede usar itemgetter(0) también para ordenar por clave.
 Ejemplo
import operator
D={"danza":"baile","novicio":"nuevo","reto":"desafio","fácil":"sencillo"}
LA=sorted(D)
print(LA) # ['danza', 'fácil', 'novicio', 'reto']
LD=sorted(D,reverse=True)
print(LD) # ['reto', 'novicio', 'fácil', 'danza']
LC=sorted(D.items())
print(LC) # [('danza', 'baile'), ('fácil', 'sencillo'), ('novicio', 'nuevo'), ('reto', 'desafio')]
LCD=sorted(D.items(),reverse=True)
print(LCD) # [('reto', 'desafio'), ('novicio', 'nuevo'), ('fácil', 'sencillo'), ('danza', 'baile')]
LV=sorted(D.items(),key=operator.itemgetter(1))
print (LV) # [('danza', 'baile'), ('reto', 'desafio'), ('novicio', 'nuevo'), ('fácil', 'sencillo')]
LVD=sorted(D.items(),key=operator.itemgetter(1),reverse=True)
print (LVD) # [('fácil', 'sencillo'), ('novicio', 'nuevo'), ('reto', 'desafio'), ('danza', 'baile')]
 Creación de un diccionario por comprensión
• Es similar a las listas.
Ejemplo:
import math
D={2*k:k+3 for k in [5, 2, 7, 4, 6]}
print (D) # {10: 8, 4: 5, 14: 10, 8: 7, 12: 9}
P={k:round(math.sqrt(k),2) for k in range(1,10)}
print (P) # {1: 1.0, 2: 1.41, 3: 1.73, 4: 2.0, 5: 2.24, 6: 2.45, 7: 2.65, 8: 2.83, 9: 3.0}
pal=list("murcielago") # ['m', 'u', 'r', 'c', 'i', 'e', 'l', 'a', 'g', 'o']
L={pal.index(k)+1:k for k in pal}
print(L)# {1: 'm', 2: 'u', 3: 'r', 4: 'c', 5: 'i', 6: 'e', 7: 'l', 8: 'a', 9: 'g', 10: 'o'}
 Convertir una lista a diccionario
• Para convertir una lista a un diccionario utilizamos el método dict(). Para ello
se debe tener una lista de listas o de tuplas.
Ejemplo:
L1=[[1,2],[6,"seis"],[3,4.0]]
D1=dict(L1)
print(D1) # {1: 2, 6: 'seis', 3: 4.0}
 Construir un diccionario en base a dos listas
• Para combinar dos listas y convertirlas en un diccionario utilizamos el método zip().
Ejemplo:
L1=[1,7.5,("a","b"),"Enero"]
L2=["Lima",5+2j,3.1416,[1,2,3]]
D=dict(zip(L1,L2))
print(D) # {1: 'Lima', 7.5: (5+2j), ('a', 'b'): 3.1416, 'Enero': [1, 2, 3]}
DC={L1[i]:L2[i] for i in range(len(L1))} # otra forma DC={x:L2[L1.index(x)] for x in L1}
print(DC) # {1: 'Lima', 7.5: (5+2j), ('a', 'b'): 3.1416, 'Enero': [1, 2, 3]}
 Números aleatorios entre dos números
• Python proporciona una función interna que genera números pseudoaleatorios, que no
son verdaderamente aleatorios en un sentido matemático, pero servirán para nuestros
propósitos.
• El modulo random contiene el método random() que devuelve un número en coma
flotante mayor o igual a 0.0 y menor que 1.0.
• El método randint(a, b) devuelve un número entero comprendido entre a y b (ambos
inclusive) de forma aleatoria.
• El método randrange(a, b, salto) genera números enteros aleatorios comprendidos entre
a y b separados entre sí con un salto. Al igual que range() no toma el limite b.
Es equivalente a choice(range(a, b, salto)). (ver diapositiva 24)
• El método uniform(a, b) devuelve un float aleatorio comprendido entre a y b (ambos
inclusive).
 Ejemplo
import random
x=random.random()
print (x) # 0 <= x < 1
x=random.randint(5,10)
print (x) # 5 <= x <= 10
x=random.randrange(5,11,2)
print (x) # 5 <= x < 11 con un salto de 2, o sea pueda salir 5, 7 o 9
x=random.uniform(5, 10)
print (x) # 5 <= x < =10 devuelve un x real
 Elementos aleatorios de una secuencia
• El método choice(sec) devuelve un elemento aleatorio de una secuencia.
• El método shuffle(sec) modifica el orden de los elementos de una secuencia. Esta función se asemeja a la acción de
mezclar una baraja. Modifica la lista original.
• El método sample(sec, num) devuelve num elementos aleatorios de la secuencia sec. Siguiendo con el ejemplo de la
baraja, sería similar a la acción de repartir num cartas a un jugador.
Ejemplo:
import random
L=["Lima","Arequipa","Trujillo","Puno","Cajamarca"] # También puede ser una tupla
ciudad=random.choice(L)
print(ciudad) # Muestra una ciudad al azar
L=[6,0,8,2,4,8]
random.shuffle(L) # Modifica la lista original
print (L) # Devuelve la lista barajeada
L=range(1,11)
R=random.sample(L,3)
print(R) # Devuelve una terna al azar con números del 1 al 10
 Contenido Clase 06
• Conjuntos (Sets)
• Obtener, añadir y borrar un elemento
• Tamaño y pertenencia de un conjunto
• Creación de un conjunto por comprensión
• Teoría de conjuntos
 Conjuntos
• El concepto de conjunto en Python es el mismo que en matemáticas: es una
colección no ordenada de objetos no repetidos.
• El objeto conjunto es mutable: una vez que se ha creado un conjunto, puede ser
modificado.
• Un conjunto no puede contener objetos mutables.
• Se declara usando llave ({}) como un diccionario pero separando sus elementos
solo por comas (,).
• Un conjunto vacío se declara como set() y no {} que crea un diccionario vacío.
• Puede convertir una lista o tupla a conjunto usando el método set(). También se
puede usar con diccionarios y formara un conjunto con las claves.
• Puede convertir un cadena a un conjunto de sus caracteres usando el método
set().
 Ejemplos
vacio=set()
print(vacio) # set()
continentes ={"América","Europa","Asia", "África", "Oceanía"}
print(continentes) # {'Oceanía', 'Europa', 'América', 'Asia', 'África'}
planetas=set(["Mercurio", "Venus", "Tierra", "Marte", "Júpiter", "Saturno", "Urano", "Neptuno"])
print(planetas) # {'Tierra', 'Urano', 'Mercurio', 'Saturno', 'Marte', 'Venus', 'Neptuno', 'Júpiter'}
letras=set("Hola Mundo")
print(letras) # {'l', 'M', 'd', 'u', 'H', 'o', 'n', ' ', 'a'}
conjunto=set({1:2,3:4,"cinco":5,(6,7):"seis y siete"})
print(conjunto) # {1, 'cinco', 3, (6, 7)}
L=list(continentes) #Puede usar la función list() para convertir a lista o tuple() para tupla
print(L) # ['África', 'América', 'Europa', 'Asia', 'Oceanía']
 Obtener, añadir y borrar un elemento
• Obtener un elemento: En un conjunto no existe un orden establecido para sus elementos,
por lo tanto no podemos acceder a un elemento en particular.
• Añadir un elemento: Para añadir un elemento a un conjunto utilizamos el método add().
• Borrar un elemento: Para borrar un elemento de un conjunto utilizamos el método
remove(). Para eliminar un elemento aleatoriamente utilizamos el método pop().
Ejemplo:
L={"a","e","i","o",1,2,3,None,("pi",3.1416)}
L.add("u")
L.remove("e")
x=L.pop()
print(x) #i
print(L)# {2, 3, 1, ('pi', 3.1416), None, 'a', 'u', 'o'}
 Tamaño y pertenencia de un conjunto
• Para conocer el número de elementos que tiene un conjunto utilizamos la
función len().
• Para saber si un elemento pertenece o no a un conjunto usamos los
operadores in y not in.
Ejemplo:
continentes ={"América","Europa","Asia", "África", "Oceanía"}
print(len(continentes)) #5
print("Atlantida" in continentes) # False
print("Atlantida" not in continentes) # True
 Creación de un conjunto por comprensión
A={x for x in range(10)}
print (A) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
D={1:2,3:4,(5,6):("cinco","seis"),"siete":7}
B={D[i] for i in D.keys()}
print(B) # {2, ('cinco', 'seis'), 4, 7}
C = {x for x in "abracadabra" if x not in "abc"}
print(C) # {'d', 'r’}
mult3= {n for n in range(20) if n % 3 == 0}
print(m3) # {0, 3, 6, 9, 12, 15, 18}
 Teoría de conjuntos
• Dados 2 conjuntos a y b:
a={2,4,5,6,7,9}
b={1,3,5,6,8,9,0}
c={5,4,9}
u=a|b |c
print(u)
i=a&b
print(i)
print(c<a)
print(c<b)
print(set()<a)
 Contenido Clase 07
• Cadenas (Strings)
• Acceso a los caracteres de la cadena
• Formato de cadenas
• Alineando cadenas
• Reemplazando cadenas
• Buscando cadenas
• Dividir y unir cadenas
• Presentación de cadenas
• Código de un carácter
• Rellenar una cadena y contar subcadena
• Principio y fin de una cadena
 Cadenas (Strings)
• Los cadenas (strings) son un tipo de dato compuesto por una secuencia de
caracteres que representan un texto. Estas cadenas de texto son de tipo str y se
delimitan mediante el uso de comillas simples o dobles.
• Cada uno de los caracteres de una cadena (incluidos los espacios) tiene asignado
un índice.
• Las cadenas son inmutables.
Ejemplo: La cadena "Python"
 Acceso a los caracteres de la cadena
• El acceso a los caracteres de una cadena son los mismos que para las listas.
Ejemplo:
cadena = "Esto es una cadena de texto ¡Oh!"
print(cadena[3:len(cadena):2])
print(cadena[::-1])
cadena=cadena+cadena[len(cadena)-4:]*3
print(cadena)
Salida:
oe n aead et O!
!hO¡ otxet ed anedac anu se otsE
Esto es una cadena de texto ¡Oh!¡Oh!¡Oh!¡Oh!
 Formato de cadenas
Sea x una cadena:
• x.upper(): devuelve una copia de la cadena convirtiendo las letras minúsculas a mayúsculas.
• x.lower(): devuelve una copia de la cadena convirtiendo las letras mayúsculas a minúsculas.
• x.title(): devuelve una copia de la cadena usando la notación de título.
• x.capitalize(): devuelve una copia de la cadena convirtiendo en mayúscula solo la primera letra.
• x.swapcase(): devuelve una copia de la cadena convertidas las mayúsculas en minúsculas y viceversa.
Ejemplo:
cadena = "esTO es una CADena de teXto ¡oH!"
print(cadena.upper()) # ESTO ES UNA CADENA DE TEXTO ¡OH!
print(cadena.lower()) # esto es una cadena de texto ¡oh!
print(cadena.title()) # Esto Es Una Cadena De Texto ¡Oh!
print(cadena.capitalize()) # Esto es una cadena de texto ¡oh!
print(cadena.swapcase()) # ESto ES UNA cadENA DE TExTO ¡Oh!
 Alineando cadenas
• {:<10} campo de 10 caracteres, alineando a la izquierda.
Se añaden espacios a la derecha hasta completar 10.
• {:>10} campo de 10 caracteres, alineando a la derecha.
Se añaden espacios a la izquierda hasta completar 10.
• {:^10} campo de 10 caracteres, alineando en el centro.
Se añaden espacios por la izquierda y derecha hasta
completar 5, de forma que el texto quede centrado.
• Puede colocar un carácter de relleno después de los dos
puntos.
Ejemplo:
for x in range(1,11):
print ("{3}{0:<10.2f}{3}{3}{1:.^10d}{3}{3}{2:>10d}{3}".format(x, x * x, x * x * x, "|"))
Ejemplo:
for x in range(1,11):
print ("{5}{0:<8}{5}{1:8}{5}{2:^8}{5}{3:>8}{5}{4:8}{5}".format(x,"Juan", "Rosa", "Lee",25,"|"))
 Alineando cadenas
Sea x una cadena:
• x.center(campo,carácter de relleno): devuelve una copia de la cadena centrada.
• x.ljust(campo, carácter de relleno): devuelve una copia de la cadena alineada a la izquierda.
• x.rjust(campo, carácter de relleno): devuelve una copia de la cadena alineada a la derecha.
• El campo es el tamaño total que ocupa la cadena y el relleno.
• Si no coloca el carácter, asume que es el espacio en blanco.
Ejemplo:
cadena = "Lista de empleados"
print (cadena.center(50, "="))# ================Lista de empleados================
print (cadena.ljust(50, "=")) # Lista de empleados================================
print (cadena.rjust(50, "=")) # ================================Lista de empleados
print(cadena.center(50)) # Lista de empleados
 Reemplazando cadenas
Sea x una cadena:
• x.lstrip(caracteres): devuelve una copia de la cadena a la cual se le han eliminado los caracteres del
principio. Si no se coloca nada elimina los espacios en blanco.
• x.rstrip(caracteres): devuelve una copia de la cadena a la cual se le han eliminado los caracteres del
final. Si no se coloca nada elimina los espacios en blanco.
• x.strip(caracteres): devuelve una copia de la cadena a la cual se le han eliminado los caracteres de
ambos lados. Si no se coloca nada elimina los espacios en blanco.
Ejemplo:
cadena1 = " .,,;.:Hola:) estimados, ... amigos,;,:),;"
cadena2= " Hola otra vez "
print ("x"+cadena1+"x") #x .,,;.:Hola:) estimados, ... amigos,;,:),;x
print("x"+cadena1.lstrip(";):,. ")+"x") # xHola:) estimados, ... amigos,;,:),;x
print("x"+cadena1.rstrip(";):,. ")+"x") # x .,,;.:Hola:) estimados, ... amigosx
print ("x"+cadena1.strip(";):,. ")+"x") # xHola:) estimados, ... amigosx
print ("x"+cadena2.strip()+"x") #xHola otra vezx
 Reemplazando cadenas
Sea x una cadena:
• x.replace(subcadena1, subcadena2, ocurrencias): devuelve una copia de la
cadena a la cual se le ha reemplazado la subcadena1 por la subcadena2 el
número de ocurrencias especificado.
• Si la cadena1 no se encuentra en la cadena x, entonces no hace nada.
Ejemplo:
cadena = "Esto es una cadena de texto y tiene un concepto notorio"
print(cadena.replace("to", "tatu")) # Estatu es una cadena de textatu y tiene un conceptatu notaturio
print(cadena.replace("to", "tatu",2)) # Estatu es una cadena de textatu y tiene un concepto notorio
 Buscando cadenas
Sea x una cadena:
• x.find(subcadena,inicio,fin): Busca una subcadena dentro de una cadena.
Ejemplo:
cadena = "No hay camino para la verdad, la verdad es el camino."
print(len(cadena)) # devuelve 53, la longitud de la cadena
print(cadena.index("v")) # devuelve 22, el índice de la primera "v"
print (cadena.find("ver")) # devuelve 22, o sea el índice de "v"
print (cadena.find("ver", 22)) # busca a partir de 22 y devuelve 22, o sea el índice de "v"
print (cadena.find("ver", 23)) # busca a partir de 23 y devuelve 33, o sea el siguiente índice de "v"
print (cadena.find("ver", 23,30)) #devuelve -1 porque no encontró "ver"
 Dividir y unir cadenas
Sea x una cadena:
• x.split(separador): devuelve una lista de las palabras de la cadena separadas acorde el parámetro
separador. Si este parámetro no se especifica aplica sobre los espacios en blanco.
• x.join: convierta una lista en una cadena de texto.
Ejemplo:
cadena1 = " Esto es una cadena de texto ¡Oh! "
cadena2="Esta/es/otra cadena/¡Oh!"
email = "[email protected]"
print(cadena1.split()) # ['Esto', 'es', 'una', 'cadena', 'de', 'texto', '¡Oh!’]
print(cadena1.split(" ")) # ['Esto', '', '', '', '', '', 'es', '', '', '', '', '', 'una', '', '', '', '', '', 'cadena', '', '', '', '', '', 'de', '', '', '', '', '', 'texto', '', '', '', '', '', '', '¡Oh!']
lista=cadena2.split("/")
print(lista) # ['Esta', 'es', 'otra cadena', '¡Oh!']
print(email.split("@")) # ['diaz_cm', 'up.edu.pe']
print("-".join(lista)) # Esta-es-otra cadena-¡Oh!
 Presentación de cadenas
• Una alternativa a la concatenación de cadenas es el uso del método format. Este método devuelve una copia de la cadena a la
que se le han sustituido las posiciones que contienen llaves ({}) por los argumentos del método. Esta sustitución se realiza por
defecto en el mismo orden de los argumentos.
Ejemplo:
nombre = input("Ingresa tu nombre: ")
edad = int(input("Ingresa tu edad: "))
nombreMascota = input("Ingresa el nombre de tu mascota: ")
print ("Tu nombre es {} y tienes {} años.".format(nombre.upper(), edad))
print ("Tu mascota se llama {} y tiene {} caracteres.".format(nombreMascota,len(nombreMascota)))
print ("Tu mascota se llama {2}. Tu eres {0} y tienes {1} años.".format(nombre, edad, nombreMascota))
Ejemplo:
pi=3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170
679
nombre= "Rodolfo"
print("{0} el número pi es {1:10.4f}".format(nombre,pi))
# 1 es el índice del segundo argumento de la función format o sea pi
# 10 es el tamaño del campo reservado para el número incluyendo el punto
# 4 es la cantidad de decimales redondeado del número
# f si el número es float, d si el número es entero
 Presentación de cadenas
• Otra alternativa es utilizar las cadenas f (f-Strings), nos da la oportunidad de ejecutar funciones dentro de la cadena.
Ejemplo:
nombre = input("Ingresa tu nombre: ")
edad = int(input("Ingresa tu edad: "))
nombreMascota = input("Ingresa el nombre de tu mascota: ")
print (f"Tu nombre es {nombre.upper()} y tienes {edad} años.")
print(f"Tu mascota se llama {nombreMascota} y tiene {len(nombreMascota)} caracteres.")
print (f"Tu mascota se llama {nombreMascota}. Tu eres {nombre} y tienes {edad} años.")
Ejemplo:
pi=3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170
679
nombre= "Rodolfo"
print(f"{nombre} el número pi es {pi:10.4f}")
Ejemplo:
b="|"
for x in range(1,11):
print (f"{b}{x:<10.2f}{b}{b}{x*x:.^10d}{b}{b}{x*x*x:>10d}{3}")
 Código de un carácter
• Cada carácter tiene un código ANSI y se obtiene con la función ord().
• Y de forma similar, conociendo el código ANSI se puede obtener el carácter
mediante la función chr().
Ejemplo: Cambie el carácter por el que le sigue según ANSI.
cadena="Hola mundo"
for x in cadena:
xn=ord(x)+1
x=chr(xn)
print(x,end="")
 Rellenar una cadena y contar subcadena
• zfill(n): Rellena un texto anteponiendo ceros. Donde n es el tamaño del campo.
Ejemplo:
numFactura = 1575
print (str(numFactura).zfill(8)) # 00001575
• count(subcadena,inicio,fin): Cuenta la cantidad de apariciones de una subcadena.
Ejemplo:
cadena = "Esto es una cadena de texto y tiene un concepto notorio"
print (cadena.count("to")) #4
print (cadena.count("to",2)) #4
print (cadena.count("to",3)) #3
print (cadena.count("to",0,3)) #0
print (cadena.count("to",0,4)) #1
print (cadena.count("to",10,50))# 2
 Principio y fin de una cadena
• startswith(subcadena,inicio,fin): Comprueba si una cadena comienza con una subcadena
determinada.
cadena = "Esto es una cadena de texto y tiene un concepto notorio"
print (cadena.startswith("Es")) # True
print (cadena.startswith("texto")) # False
print(cadena.index("t",3)) # devuelve 22, o sea el índice de la "t" después de la primera "t "
print (cadena.startswith("texto", 22)) # True
• endswith(subcadena,inicio,fin): Comprueba si una cadena finaliza con una subcadena
determinada.
cadena = "Esto es una cadena de texto y tiene un concepto notorio"
print (cadena.endswith("tre")) # False
print (cadena.endswith("texto")) # False
print(cadena.index("to",3)) # devuelve 25, o sea el índice de la "to" después del primer "to"
print (cadena.endswith("texto",0,27)) # True