Ejercicios – Fundamentos de la Programación

Ejercicio 01

Determina el tipo de dato correcto de los siguientes ejemplos:

• 25 -> Número Entero (int)
• “Barcelona” -> Cadena de Texto (str)
• 12.0 -> Número con Coma Flotante (float)
• True -> Booleano (bool)
• “” -> Cadena de Texto (str)
• false -> Error de tipo, los booleanos empiezan con mayúsculas

---

Ejercicio 02

Crea el programa más famoso de todo el sector de la programación: Hola Mundo. Este simplemente muestra por pantalla la cadena “¡Hola Mundo!”.

print("¡Hola Mundo!")

Este ejercicio no tiene ninguna complicación, simplemente debemos mostrar la cadena por pantalla mediante la función print().

---

Ejercicio 03

Crea un programa cuya finalidad sea el cálculo del área de un círculo (π·r²).

r = float(input("Introduce el radio del círculo: "))
a = 3.14*r*r
print("El área del círculo es: ", a)

Ahora ya nos enfrentamos a un ejercicio algo más complejo. Lo más importante es recordar que la función input(), que nos permite interactuar con el usuario y que este introduzca datos al programa, siempre nos generará una cadena de texto, por lo que es necesario convertirla mediante la función float() para poder operar con dicho valor (línea 1).

El resto es sencillo: simplemente operar con los datos y mostrar el resultado por pantalla.

---

Ejercicio 04

Crea un programa que reciba dos números enteros y nos indique si uno es mayor o menor que otro o si son iguales.

a = int(input("Introduce el primer número: "))
b = int(input("Introduce el segundo número: "))
if a > b:
    print("El número", a, "es mayor que el número", b)
elif b > a:
    print("El número", a, "es menor que el número", b)
else:
    print("Ambos números son iguales")

Veamos este código:

• Las dos primeras líneas se encargan de obtener los datos del usuario. Atención a la conversión a enteros, pues era uno de los requisitos del ejercicio.
• A continuación utilizamos la sentencia «if» para ver si el primero es mayor que el segundo. De ser cierto, se indica al usuario.
• En la línea 5 hemos utilizado la sentencia «elif» en lugar de anidar sentencias «if/else».
• Finalmente, si ninguna de las condiciones se han cumplido, sólo nos queda la opción de que sean iguales, así que lo indicamos sin necesidad de realizar ninguna comprobación extra.

---

Ejercicio 05

En este ejercicio vas a tener que programar una calculadora básica. Al usuario se le pedirá que introduzca dos números, para posteriormente mostrarle un menú desde el que seleccionará la operación a realizar (suma, resta, multiplicación o división). La calculadora deberá ejecutarse de forma continua hasta que el usuario seleccione la opción de salir del menú.

print("-------------")
print(" CALCULADORA ")
print("-------------")
 
# MENU EN BUCLE
while True:
     
    print("==========================")
    print("Selecciona la operación:")
    print("1- SUMA")
    print("2- RESTA")
    print("3- PRODUCTO")
    print("4- DIVISIÓN")
    print("5- SALIR")
    print("==========================")
    opcion = int(input("Opción: "))
     
    # Comprobamos si el usuario quiere salir
    if(opcion == 5):
        break
     
    # Introducción de Operandos y Operación
    op1 = float(input("Introduce el primer operando: "))
    op2 = float(input("Introduce el segundo operando: "))
     
    if(opcion == 1):
        #SUMA
        resultado = op1 + op2
        print("La suma es: ", resultado)
    elif(opcion == 2):
        #RESTA
        resultado = op1 - op2
        print("La resta es: ", resultado)
    elif(opcion == 3):
        #PRODUCTO
        resultado = op1 * op2
        print("El producto es: ", resultado)
    elif(opcion == 4):
        #DIVISION
        if(op2 == 0):
            print("No se puede dividir por cero")
        else:
            resultado = op1 / op2
            print("La división es: ", resultado)
    else:
        #ERROR
        print("ERROR: Opción No Valida")

Estamos ante nuestro programa más largo hasta ahora, aunque no por ello el más complejo. Veámoslo en detalle:

• En las primeras líneas le mostramos al usuario que programa está ejecutando. Esta es una buena práctica, e incluso podría ir acompañada de una breve descripción de uso y la versión actual.
• En la línea 6 comienza el bucle principal del programa. En esta ocasión, he optado por un bucle continuo que se deberá romper desde el interior del mismo, pero otra posible implementación sería comprobar la opción del usuario como condición del bucle.
• Esta versión utiliza un menú creado a base de texto para interactuar con el usuario: se le muestran distintas opciones, y a continuación se le solicita que introduzca la desea. Hoy en día básicamente sólo se utilizan interfaces gráficas, pero en este curso no se verán (quizás en próximos).
• El if de salir se debe escribir antes de la solicitud de operandos, fuera del grupo de resto de opciones. De no ser así, se solicitarían los operandos e inmediatamente se saldría del programa, cosa que no tiene mucho sentido.
• Prestad atención a la línea 40. Dado que no es posible matemáticamente dividir por cero, tenemos que asegurarnos de que no es así antes de realizar la operación.
• Finalmente, en la línea 45 tratamos cualquier opción errónea introducida por el usuario que no esté en el menú.

Este programa podría mejorarse mucho, pero a estas alturas del curso, considero que cumple con el contenido suficiente.

---

Ejercicio 06

Escribe un programa que solicite un número al usuario y a continuación muestre el factorial del mismo.

print("-CALCULO DE FACTORIAL-")
numero = int(input("Introduce un número: "))
factorial = 1
 
# EL NÚMERO DEBE SER POSITIVO
if(numero < 0):
    numero *= -1
 
while(numero > 1):
    factorial *= numero
    numero -= 1
 
print("El factorial es: ", factorial)

• En la línea 3, inicializamos el valor del factorial a 1. De esta forma, tenemos cubiertos ya los casos donde el número introducido sea 0 o 1.
• Dado que sólo existen los factoriales de números naturales (enteros positivos), mediante el if de la línea 6 nos aseguramos de que así sea (en la mayoría de calculadoras científicas, los factoriales de números negativos se calculan como si fueran positivos, así que aquí hacemos lo mismo).
• El bucle de la línea 9 realiza el cálculo del factorial en si. Mediante la condición, nos aseguramos de que sólo se calcule si el número es mayor que 1, dado que los casos anteriores a este ya están tratados. El contenido del bucle es simplemente la fórmula de calculo del factorial.

---

Ejercicio 07

Escribe un programa que, una vez solicitado al usuario un vector de cualquier dimensión, calcule la media de todos sus elementos.

vector = []
media = 0

longitud = int(input("Introduce la longitud del vector a generar: "))

# Generación del vector
for i in range(0, longitud):
    elemento = float(input("Introduce el elemento "+str(i)+": "))
    vector.append(elemento)
    
#Calculo de la media
for i in vector:
    media += i

media = media / longitud

print("La media del vector es: ", media)

• En la línea 1 inicializamos la variable vector como una lista vacía, para posteriormente ir añadiéndole los elementos necesarios
• El bucle de la línea 7 es el típico de creación de listas. En este caso, se le ha solicitado previamente la longitud de la misma al usuario.
• El segundo bucle (línea 12) se encarga de calcular la media. Fijaos lo útil que resulta el bucle For-In para recorrer listas.

---

Ejercicio 08

Crea un programa que implemente el ejemplo mostrado anteriormente para ordenar una lista mediante el método de la burbuja.

# MÉTODO BURBUJA
lista = [2, 5, 4, 3, 1]

#BUCLE QUE CONTROLA LAS ITERACIONES DE BÚSQUEDA
for i in range(1, len(lista)):
	#BUCLE QUE RECORRE LA LISTA
	for j in range(0, len(lista)-i):
		if(lista[j] > lista[j+1]):
			elemento = lista[j]
			lista[j] = lista[j+1]
			lista[j+1] = elemento

print(lista)

*El algoritmo está completamente comentado en la sección correspondiente del curso

---

Ejercicio 09

Escribe un programa que, tomando como origen un texto con un número indeterminado de espacios entre las palabras, devuelva el mismo texto con únicamente espacios simples.

cadena = "Hola     a   todo      el             mundo"

lista = cadena.split()
cadena = " ".join(lista)

print(cadena)

Estamos ante un ejercicio bastante sencillo si hacemos uso de las funciones para interactuar con cadenas de las que dispone Python:

• En la línea 3 hacemos uso de la función split() para separar los elementos de la cadena en una lista.
• Posteriormente, en la línea 4, generamos una nueva cadena mediante join(), utilizando como carácter de unión el espacio en blanco.

---

Ejercicio 10

Escribe un programa que le solicite al usuario dos matrices (de cualquier dimensión), para a continuación poder realizar la suma o el producto de las mismas (si es posible). Tras finalizar, deberá mostrar la matriz resultado por pantalla.

###################################################
# MATRIZ A - CREACIÓN E INTRODUCCIÓN DE ELEMENTOS
###################################################

fil1 = int(input("Introduce las filas de la matriz A: "))
col1 = int(input("Introduce las columnas de la matriz A: "))
m1 = []

for i in range(fil1):
    m1.append([0] * col1)

for i in range(fil1):
    for j in range(col1):
        m1[i][j] = float(input("Introduce el elemento ("+str(i)+","+str(j)+") de la Matriz A: "))

###################################################
# MATRIZ B - CREACIÓN E INTRODUCCIÓN DE ELEMENTOS
###################################################

fil2 = int(input("Introduce las filas de la matriz B: "))
col2 = int(input("Introduce las columnas de la matriz B: "))
m2 = []

for i in range(fil2):
    m2.append([0] * col2)

for i in range(fil2):
    for j in range(col2):
        m2[i][j] = float(input("Introduce el elemento ("+str(i)+","+str(j)+") de la Matriz B: "))

###################################################
# OPERACIONES SOBRE LAS MATRICES
###################################################

print("Seleccióna la operación a realizar: ")
print("1- SUMA")
print("2- PRODUCTO")
opcion = int(input("Operación: "))

if opcion == 1:
    #SUMA - COMPROBAMOS SI ES POSIBLE
    if (fil1 != fil2) or (col1 != col2):
        print("ERROR: Las matrices no pueden sumarse.")
    else:
        #CREACIÓN MATRIZ RESULTADO
        resultado = []
        for i in range(fil1):
            resultado.append([0] * col1)

        #SUMA
        for i in range(fil1):
            for j in range(col1):
                resultado[i][j] = m1[i][j] + m2[i][j]

        #VISUALIZACIÓN DEL RESULTADO
        for i in range(len(resultado)):    
            print(resultado[i])
     
elif opcion == 2:
    #PRODUCTO - COMPROBAMOS SI ES POSIBLE
    if (col1 != fil2):
        print("ERROR: Las matrices no pueden multiplicarse.")
    else:
        #CREACIÓN MATRIZ RESULTADO
        resultado = []
        for i in range(fil1):
            resultado.append([0] * col2)

        #SUMA
        for i in range(fil1):
            for j in range(col2):
                    for k in range(col1):
                        resultado[i][j] = m1[i][k] * m2[k][j]

        #VISUALIZACIÓN DEL RESULTADO
        for i in range(len(resultado)):    
            print(resultado[i])
else:
    #ERROR
    print("Opción no valida.")

Estamos ante el primer ejercicio que realmente nos requiere unos ciertos conocimientos matemáticos, aunque las operaciones han sido descritas en el apartado correspondiente del curso. Veamos algunos detalles:

• De la línea 1 a la 29, el programa crea las matrices solicitadas por el usuario y va introduciendo los elementos de las mismas uno a uno.
• El menú ofrece dos opciones: suma y producto. En esta ocasión, no se ha creado un bucle para realizar operaciones continuas.
• Las líneas 42 y 61 se encargar de comprobar que las operaciones puedan ser realizadas.
• Los algoritmos para la suma y el producto ya han sido comentados en el curso.
• Por último, la matriz resultado es mostrada por pantalla línea a línea.

---

Ejercicio 11

Reescribe la calculadora desarrollada en el ejercicio 5, utilizando para ello funciones que simplifiquen la lectura del código.

#####################################
# Ejercicio Calculadora, Versión 2.0
#####################################

def menu():
    print("==========================")
    print("Selecciona la operación:")
    print("1- SUMA")
    print("2- RESTA")
    print("3- PRODUCTO")
    print("4- DIVISIÓN")
    print("5- SALIR")
    print("==========================")
    return int(input("Opción: "))

def suma():
    op1 = float(input("Introduce el primer operando: "))
    op2 = float(input("Introduce el segundo operando: "))
    return op1 + op2
def resta():
    op1 = float(input("Introduce el primer operando: "))
    op2 = float(input("Introduce el segundo operando: "))
    return op1 - op2
    
def producto():
    op1 = float(input("Introduce el primer operando: "))
    op2 = float(input("Introduce el segundo operando: "))
    return op1 * op2
    
def division():
    op1 = float(input("Introduce el primer operando: "))
    op2 = float(input("Introduce el segundo operando: "))
    return op1 / op2

#####################
# PROGRAMA PRINCIPAL
#####################
print("--------------------")
print(" CALCULADORA SIMPLE ")
print("--------------------")

opcion = menu()
while opcion != 5:
    if(opcion == 1):
        resultado = suma()
    elif(opcion == 2):
        resultado = resta()
    elif(opcion == 3):
        resultado = producto()
    elif(opcion == 4):
        resultado = division()
    else:
        #ERROR
        print("ERROR: Opción No Valida")
    print("La resultado de la operación es: ", resultado)
    opcion = menu()

• Se trata de una simple reestructuración del ejercicio 5. Se han creado funciones para cada operación, así como para mostrar el menú.
• La función menú devuelve el valor de la opción introducida por el usuario.
• El resto simplemente realiza la operación correspondiente, solicitando los operandos dentro de la misma función (se podrían haber creado funciones para esta tarea, pero se ha desestimado).

---

Ejercicio 12

Escribe un programa que simule el funcionamiento de un cajero automático. Este cajero dispondrá de billetes de 1, 10 y 50 €, iniciando con 100 unidades de cada uno. El programa deberá mostrar por pantalla la cantidad de billetes devueltos, así como un aviso si no dispone de suficiente saldo.

#####################################
# CAJERO AUTOMÁTICO
#####################################

# BILLETES EN CAJERO
b1 = 100
b10 = 100
b50 = 100

def sacarDinero(cantidad):
    global b1, b10, b50
    # COMPROBAMOS SI QUEDA SALDO
    if cantidad <= (b1) + (b10 * 10) + (b50 * 50):
        # BILLETES DE 50
        d50 = int(cantidad / 50)
        if d50 > b50:
            # NO QUEDAN SUFICIENTES BILLETES
            d50 = b50
        cantidad = cantidad - (d50 * 50)
            
        # BILLETES DE 10
        d10 = int(cantidad / 10)
        if d10 > b10:
            # NO QUEDAN SUFICIENTES BILLETES
            d10 = b10
        cantidad = cantidad - (d10 * 10)
        
        # BILLETES DE 1
        d1 = cantidad
        if d1 > b1:
            # NO QUEDAN SUFICIENTES BILLETES
            d1 = b1
        cantidad = cantidad - d1
        
        if cantidad == 0:
            # TODO HA IDO BIEN, ACTUALIZAMOS CANTIDAD Y DEVOLUCIÓN
            b50 -= d50
            b10 -= d10
            b1 -= d1
            return [d50, d10, d1]
        else:
            return [-1, -1, -1]
    else:
        return [-1, -1, -1]

#####################
# PROGRAMA PRINCIPAL
#####################
def main():
    salir = False
    while not salir:
        print("---------------------------")
        cantidad = int(input("Cantidad a retirar (-1 para salir): "))
        if cantidad >= 0:
            [d50, d10, d1] = sacarDinero(cantidad)
            if [d50, d10, d1] != [-1, -1, -1]:
                print(str(d50)+" billetes de 50 (Quedan "+str(b50)+")")
                print(str(d10)+" billetes de 10 (Quedan "+str(b10)+")")
                print(str(d1)+" billetes de 1 (Quedan "+str(b1)+")")
            else:
                print("El cajero no dispone de suficiente saldo para retirar "+str(cantidad))
        else:
            salir = True

main()

PROGRAMA PRINCIPAL

• Al principio del programa, se han definido la cantidad de billetes, que serán variables globales.
• El programa permite la continua extracción de dinero, utilizando como disparador para la salida la introducción de una cantidad negativa (utilizar el valor de -1 para salir de programar es algo común en terminal).
• Tras la llamada a la función sacarDinero(), su muestra por pantalla el número de billetes devueltos y los restantes en el cajero.
• De no existir suficiente saldo, se le comunica al usuario.

sacarDinero(cantidad)

• En la línea 11, se importan las variables globales, para así mantener actualizado en todo momento el número de billetes.
• En primer lugar (línea 13), nos aseguramos de que es posible devolver la cantidad de saldo solicitada.
• A continuación, comenzamos a calcular el número de billetes (L15, L22 y L29), de mayor a menor valor. En caso de no haber suficientes de un tipo, se entregan todos los restantes.
• Una vez conocida la cantidad de billetes, se reduce la cantidad restante a devolver (L19, L26 y L33).
• Si todo ha ido bien, la cantidad restante ha de ser 0. En dicho caso, se devuelve una lista con el número de billetes de cada valor. En caso de haber habido algún fallo, se devuelve una lista con el valor de -1 (en la mayoría de casos, las funciones devuelven un valor negativo cuando ha ocurrido algún error).

---

Ejercicio 13

Escribe un programa que implemente la solución recursiva para el problema de las Torres de Hanói.

def hanoi(n, origen, auxiliar, destino):
    if n == 1:
        print("Mueve el disco superior de la pila "+str(origen)+" a la pila "+str(destino))
    else:
        hanoi(n-1, origen, destino, auxiliar)
        print("Mueve el disco superior de la pila "+str(origen)+" a la pila "+str(destino))
        hanoi(n-1, auxiliar, origen, destino)

hanoi(4,1,2,3)

• Nuestro primer objetivo es pasar el último disco de la primera pila a la última. Para eso, tenemos que tener todos los discos menos el último en la pila auxiliar.
• Para alcanzar dicha situación, debemos resolver primero el mover todos los discos menos uno de la primera pila a la auxiliar.
• Ahora debemos mover el disco de la pila inicial a la última.
• Y por último, resolver el problema de Hanoi, teniendo tres discos en la pila auxiliar que han de pasar a la última.

---

Ejercicio 14

Crea una agenda que nos permita almacenar el nombre, apellidos y teléfono de nuestros contactos. El programa deberá permitir la creación de contactos, el borrado, la búsqueda de un contacto y la visualización de la agenda con los contactos ordenados alfabéticamente.

Programa Principal (ej12.py)

from modAgenda import *

salir = False

while not salir:
    print("---------------")
    print("1- Añadir Contacto")
    print("2- Buscar Contacto")
    print("3- Borrar Contacto")
    print("4- Mostrar Agenda")  
    print("5- SALIR")
    print("---------------")
    opcion = int(input("OPCION: "))
    
    if opcion == 1:
        contacto = nuevaPersona()
        anyadePersona(contacto)
    elif opcion == 2:
        contacto = nuevaPersona()
        buscaPersona(contacto) 
    elif opcion == 3:
        contacto = nuevaPersona()
        borraPersona(contacto) 
    elif opcion == 4:
        muestraAgenda()
    elif opcion == 5:
        salir = True
    else:
        print("Opcion no Valida.")

• El programa principal consiste en un simple menú que le permite al usuario realizar cuatro acciones sobre la agenda: añadir un contacto, buscar un contacto, eliminar un contacto y mostrar toda la agenda.
• Como novedad, en la primera linea se utiliza la expresión «import *». Aquí el asterisco hace referencia a todo el contenido del módulo.

Módulo Agenda (modAgenda.py)

agenda = []

class Persona:
    def __init__(self, nombre, apellido1, apellido2, telefono):
        self.nombre = nombre
        self.apellido1 = apellido1
        self.apellido2 = apellido2
        self.telefono = telefono

# FUNCIONES DE USO INTERNO
def muestraPersona(persona):
    print("%s %s, %s" % (persona.apellido1, persona.apellido2, persona.nombre))
    print("TELF: %d" % (persona.telefono))

def intercambiaPersona(p1, p2):
    elemento = Persona(p1.nombre, p1.apellido1, p1.apellido2, p1.telefono)
    #Copiamos p2 en p1
    p1.nombre = p2.nombre
    p1.apellido1 = p2.apellido1
    p1.apellido2 = p2.apellido2
    p1.telefono = p2.telefono
    #Copiamos p1 en p2
    p2.nombre = elemento.nombre
    p2.apellido1 = elemento.apellido1
    p2.apellido2 = elemento.apellido2
    p2.telefono = elemento.telefono

def ordenaAgenda(agenda):
    for i in range(1, len(agenda)):
        for j in range(0, len(agenda)-i):
            if(agenda[j].apellido1 > agenda[j+1].apellido1):
                intercambiaPersona(agenda[j], agenda[j+1])
            elif (agenda[j].apellido1 == agenda[j+1].apellido1):
                if(agenda[j].apellido2 > agenda[j+1].apellido2):
                    intercambiaPersona(agenda[j], agenda[j+1])
                elif (agenda[j].apellido2 == agenda[j+1].apellido2):
                    if(agenda[j].nombre > agenda[j+1].nombre):
                        intercambiaPersona(agenda[j], agenda[j+1])

# FUNCIONES DE USO EXTERNO    

def nuevaPersona():
    nombre = input("Introduce el nombre del contacto: ")
    apellido1 = input("Introduce el primer apelllido del contacto: ")
    apellido2 = input("Introduce el segundo apellido del contacto: ")
    telefono = int(input("Introduce el teléfono del contacto: "))
    persona = Persona(nombre, apellido1, apellido2, telefono)
    return persona

def anyadePersona(persona):
    global agenda
    agenda.append(persona)
    ordenaAgenda(agenda)

def muestraAgenda():
    print("##-AGENDA-#############")
    for persona in agenda:
        muestraPersona(persona)
        print("---")
    print("#######################")
    
def borraPersona(borrar):
    borrado = False
    for i in range(len(agenda)):
        if agenda[i].nombre == borrar.nombre:
            if agenda[i].apellido1 == borrar.apellido1:
                if agenda[i].apellido2 == borrar.apellido2:
                    del agenda[i]
                    borrado = True
                    break
    if not borrado:
        print("El Contacto no ha podido ser borrado.")

def buscaPersona(busqueda):
    exito = False
    for persona in agenda:
        if (busqueda.nombre == persona.nombre) and (busqueda.apellido1 == persona.apellido1) and (busqueda.apellido2 == persona.apellido2):
            muestraPersona(persona)
            exito = True
    if not exito:
        print("La contacto solicitado no se encuentra en la agenda.")
    

if __name__ == '__main__':
    # CREAMOS TRES PERSONAS
    pepe = Persona("Pepe", "Garcia", "Perez", 666666666)
    maria = Persona("Maria", "Lopez", "Gutierrez", 215147528)
    alberto = Persona("Alberto", "Perez", "Salgado", 546987563)
    # LAS AÑADIMOS A LA AGENDA
    anyadePersona(pepe)
    anyadePersona(maria)
    anyadePersona(alberto)
    # MOSTRAMOS LA AGENDA
    muestraAgenda()
    # BUSCAMOS UNA PERSONA EXISTENTE
    buscaPersona(pepe)
    # BORRAMOS UNA PERSONA
    borraPersona(pepe)
    # MOSTRAMOS LA AGENDA
    muestraAgenda()
    # BUSCAMOS UNA PERSONA INEXISTENTE
    buscaPersona(pepe)

• Se ha creado un tipo Persona, que está formado por tres cadenas de caracteres (nombre, primer apellido y segundo apellido) y un entero (número de teléfono).

muestraPersona(persona)

• Esta función se encarga de formatear por pantalla la información contenida en un elemento del tipo Persona.

intercambiaPersona(p1, p2)

• Se trata de una función auxiliar, cuyo objetivo es intercambiar la información contenida entre dos elementos del tipo Persona. La razón de su creación es facilitar la lectura de la función ordenaAgenda(agenda).

ordenaAgenda(agenda)

• Esta función ordena alfabéticamente la agenda, utilizando para ello el método (ineficiente) de la burbuja, el cuál se ha visto en el curso.
• En este ejemplo, se ha decidido ordenar comenzando por los apellidos.

nuevaPersona()

• Su único objetivo es facilitar la organización del código a la hora de crear nuevas Personas. Tras solicitar la información requerida al usuario por pantalla, devuelve un elemento del tipo Persona.

anyadePersona(persona)

• Se utiliza simplemente para asegurarnos de que cada vez que se realiza la llamada a la función append(), a continuación se ordena la agenda.
• Atención especial al uso de ny en lugar de la ñ. Esto se debe a que no es un carácter de uso común, y generaría errores. En este caso, se ha preferido sustituirla por ny, aunque se podría, simplemente, haber buscado otro nombre para la función.

muestraAgenda()

• Un simple bucle para formatear la salida por pantalla y mostrar todas las personas en la agenda.

borraPersona(borrar)

• Esta función recorre toda la agenda, comprobando si la información del elemento «borrar» corresponde con alguno de los contenidos en la misma. En caso de ser así, elimina dicho elemento.

buscaPersona(busqueda)

• Esta función recorre toda la agenda, comprobando si la información del elemento «busqueda» corresponde con alguno de los contenidos en la misma. En caso de ser así, lo muestra por pantalla.

---

Ejercicio 15

Escribe un programa que lea los caracteres contenidos en un fichero, para posteriormente escribir el resultado en otro fichero que deberá permanecer actualizado con una línea para cada vez que se haya ejecutado el programa

import datetime

def cuentaCaracteres(nombreFichero):
    try:
        caracteres = 0
        fichero = open(nombreFichero, "r")
        caracter = fichero.read(1)

        while caracter != '':
            if caracter != '\n':
                caracteres += 1
            caracter = fichero.read(1)

        fichero.close()
        return caracteres

    except IOError:
        print("El fichero no existe.")
        return -1

def guardaRegistro(nombreFichero, caracteres):
    try:
        fichero = open("Registro.txt", "a")
        fecha = datetime.datetime.now()

        if caracteres > 0:
            fichero.write("A fecha %s, el fichero %s tiene %6d carácteres.\n" % (fecha.strftime("%x"), nombreFichero, caracteres))
        else:
            fichero.write("A fecha %s, el fichero  \"%s\" no existe.\n" % (fecha.strftime("%x"), nombreFichero))
        
        fichero.close()

    except IOError:
        print("No se ha hallado el fichero \"Registro.txt\".")

fichero = input("Introduce el nombre/ruta del fichero: ")
caracteres = cuentaCaracteres(fichero)
guardaRegistro(fichero, caracteres)

cuentaCaracteres(nombreFichero):

• Se trata de una sencilla función, que se encarga de leer los caracteres de un fichero de uno en uno. Al finalizar, devuelve el número de caracteres leídos.
• Se ha decidido obviar el carácter de salto de línea. Existen editores de texto que lo contabilizan, sobretodo los orientados a la programación. En cambio, los procesadores de texto lo ignoran al no ser un carácter visible.

guardaRegistro(nombreFichero, caracteres):

• Esta función escribe en el fichero «Registro.txt» (abierto en modo adición) la información sobre el fichero leído con anterioridad.
• La información almacenada consiste en el nombre del fichero y los caracteres que contiene. Además, se ha añadido información extra al almacenar también la fecha en que se realizó la lectura.
• Para acceder a la fecha, se ha importado el módulo datatime. Podéis consultar su uso en su página de referencia.

---