Skip to content

Parte 4: Funciones y gestión de archivos en Python ​

Bloque A. Programación Gráfica Multimedia | CDPC.1.A.4 ​

Currículo LOMLOE - Andalucía | Saberes básicos:

  • CDPC.1.A.4. Funciones.

PARTE I. Funciones en Python ​

1. ¿Qué es una función? ​

Una función es un bloque de código con nombre que realiza una tarea concreta y que podemos reutilizar cuantas veces haga falta. Programar con funciones aplica la abstracción (ocultar detalles tras un nombre) y la reutilización (escribir una vez, usar muchas). Ya usamos funciones integradas (print(), input(), range()...); ahora crearemos las nuestras con def.

1.1. Definición y llamada ​

python
def saludar():
    """Muestra un saludo por pantalla."""
    print("Hola, bienvenido a CDPC")

saludar()          # Primera llamada
saludar()          # Podemos llamarla tantas veces como queramos

Recuerda: def inicia la definición; el nombre va seguido de paréntesis y dos puntos; el cuerpo se indenta 4 espacios; la llamada se hace con saludar(). Las comillas """...""" iniciales son el docstring: documentación opcional muy recomendable.

1.2. Parámetros y argumentos ​

Los parámetros son las variables de la definición; los argumentos, los valores reales de la llamada.

python
def saludar(nombre):
    print("Hola,", nombre, "¡qué alegría verte!")

saludar("Lucía")     # argumento "Lucía"
def calcular_area_rectangulo(base, altura):
    area = base * altura
    print("El área es", area)

calcular_area_rectangulo(5, 3)     # 15

1.3. Valores por defecto ​

Un parámetro con valor por defecto puede omitirse en la llamada. Deben ir siempre después de los parámetros obligatorios.

python
def presentar(nombre, curso="1º Bachillerato", materia="CDPC"):
    print(nombre, "|", curso, "|", materia)

presentar("Ana")                              # usa ambos valores por defecto
presentar("Ana", "1º B")                      # cambia solo el curso
presentar("Ana", materia="Creación Digital")  # cambia solo la materia (por nombre)

1.4. return: devolver un resultado ​

print() muestra un valor; return devuelve un valor al lugar de la llamada, de modo que puede guardarse en una variable o usarse en una expresión. Un return además corta la ejecución de la función.

python
def sumar(a, b):
    return a + b

def es_par(numero):
    if numero % 2 == 0:
        return True
    return False

resultado = sumar(3, 4)
print("La suma es", resultado)            # 7
print("¿Es par el 8?", es_par(8))         # True
print("¿Es par el 15?", es_par(15))       # False

A diferencia de print(), que solo muestra el valor, return lo devuelve al código que llama para poder guardarlo. Una función sin return explícito devuelve None.

1.5. Ámbito de las variables ​

El ámbito (scope) determina dónde es visible una variable: las variables locales creadas dentro de una función solo existen dentro de ella, mientras que las globales (creadas fuera) son accesibles desde cualquier parte.

python
contador = 10                    # variable global

def incrementar():
    contador = 0                 # variable local: NO afecta a la global
    contador += 1
    print("Dentro:", contador)   # 1

incrementar()
print("Fuera:", contador)        # 10

Buena práctica: evita global. Prefiere que las funciones reciban datos por parámetros y devuelvan resultados con return: así son independientes y fáciles de probar.

1.6. Funciones integradas útiles ​

FunciónQué haceEjemplo
len(x)Número de elementoslen("hola") → 4
type(x)Tipo del datotype(3.14) → <class 'float'>
abs(x)Valor absolutoabs(-7) → 7
round(x, n)Redondeo a n decimalesround(3.14159, 2) → 3.14
range(a, b, p)Secuencia de númerosrange(0, 10, 2)
int(x) / float(x) / str(x)Conversión de tipoint("7") → 7
max(...) / min(...) / sum(...)Máximo, mínimo y sumamax(3, 9, 1) → 9
python
notas = [6.5, 8.0, 4.5, 9.25]
print(len(notas), max(notas), min(notas))                            # 4 9.25 4.5
print(round(sum(notas) / len(notas), 2), abs(notas[0] - notas[2]))   # 7.06 2.0

1.7. El módulo math ​

Las funciones matemáticas avanzadas viven en módulos, que se importan con import. También se puede hacer from math import pi, sqrt para usarlas sin prefijo, o import math as m con un alias corto.

python
import math

print(math.sqrt(144))         # 12.0      raíz cuadrada
print(math.ceil(4.2), math.floor(4.8))   # 5 y 4: techo y suelo
print(math.factorial(5))      # 120       5!
print(math.gcd(12, 18))       # 6         máximo común divisor
print(math.sin(math.pi / 2))  # 1.0       seno (en radianes)

1.8. Ejemplo integrador ​

python
# factura.py
import math

def calcular_precio_final(precio_base, iva=0.21, descuento=0.0):
    """Precio final aplicando IVA y descuento."""
    return round(precio_base * (1 + iva) * (1 - descuento), 2)

base = float(input("Precio base del producto: "))
final = calcular_precio_final(base)                  # IVA 21 %
rebaja = calcular_precio_final(base, descuento=0.1)  # +10 % de descuento
print("Precio con IVA:", final, "€")
print("Con descuento:", rebaja, "€")
print("Raíz cuadrada del precio:", round(math.sqrt(final), 2))

PARTE II. Gestión de archivos con Python ​

2. ¿Qué es un archivo? ​

Un archivo (o fichero) es un conjunto de datos almacenado de forma permanente en un dispositivo de almacenamiento. Las variables viven en la memoria RAM y desaparecen al cerrar el programa; los archivos viven en el disco y permiten conservar la información entre ejecuciones.

Los archivos que usaremos en esta asignatura son, sobre todo, archivos de texto: su contenido son caracteres legibles (notas, listas, tablas, configuración). Los archivos binarios (imágenes, vídeo, ejecutables) se estudian más adelante.

2.1. Rutas y codificación ​

Para localizar un archivo necesitamos su ruta:

  • Ruta relativa: parte de la carpeta desde la que se ejecuta el programa. Ejemplo: "datos/notas.txt".
  • Ruta absoluta: indica la ubicación completa desde la raíz del sistema. Ejemplo: "/home/ana/datos/notas.txt".

La extensión (.txt, .csv, .json...) orienta sobre el contenido, pero no lo determina.

El encoding es la tabla de caracteres con la que se interpreta el texto. Para que las tildes, la ñ y los símbolos se guarden correctamente, usa siempre encoding="utf-8".

python
ruta = "datos/notas.txt"   # ruta relativa a la carpeta del programa

Codificación

Si al leer un archivo ves caracteres extraños como á, es muy probable que se haya guardado con otra codificación. Abre y guarda siempre con encoding="utf-8".

2.2. Abrir y cerrar con open() ​

La función open(ruta, modo, encoding) abre un archivo y devuelve un objeto archivo con el que podemos leer o escribir. Cuando terminamos, hay que cerrarlo con close() para liberar el recurso y asegurar que los datos se escriben en disco.

python
archivo = open("notas.txt", "r", encoding="utf-8")
contenido = archivo.read()
print(contenido)
archivo.close()

Cierra siempre el archivo

Si ocurre un error entre open() y close(), la instrucción de cierre puede no ejecutarse y el archivo quedará abierto. Para evitarlo se usa la sentencia with.

2.3. La sentencia with: cierre automático ​

La forma recomendada de trabajar con archivos es with. Al salir del bloque, Python cierra el archivo automáticamente, incluso si se produce un error.

python
with open("notas.txt", "r", encoding="utf-8") as archivo:
    contenido = archivo.read()

print(contenido)   # aquí el archivo ya está cerrado

2.4. Modos de apertura ​

ModoSignificado¿Crea el archivo?¿Borra su contenido?
"r"LecturaNo (error si no existe)No
"w"EscrituraSíSí
"a"Añadir al final (append)SíNo
"x"Creación exclusivaSí (error si ya existe)—
"r+"Lectura y escrituraNoNo
"b"Modo binario (se combina: "rb", "wb")——

El modo por defecto es "r". Ten cuidado con "w": vacía el archivo si ya existía.


3. Leer archivos ​

3.1. read(): todo el contenido ​

read() devuelve todo el contenido del archivo como una cadena de texto. Admite un número opcional de caracteres: read(10) lee solo los 10 primeros.

python
with open("notas.txt", "r", encoding="utf-8") as archivo:
    texto = archivo.read()

print(texto)

3.2. readline() y readlines() ​

  • readline() lee una línea cada vez (incluye el salto de línea \n).
  • readlines() devuelve una lista con todas las líneas.
python
with open("notas.txt", "r", encoding="utf-8") as archivo:
    primera = archivo.readline()
    print("Primera línea:", primera.strip())

with open("notas.txt", "r", encoding="utf-8") as archivo:
    lineas = archivo.readlines()
    print("Número de líneas:", len(lineas))

3.3. Recorrer el archivo línea a línea ​

La forma más habitual y eficiente de leer un archivo es recorrerlo con un bucle for. Cada iteración obtiene una línea.

python
with open("notas.txt", "r", encoding="utf-8") as archivo:
    for linea in archivo:
        print(linea.strip())   # strip() elimina el salto de línea final

3.4. Procesar los datos leídos ​

Leer un archivo casi siempre implica transformar el texto en datos útiles: convertir a número, separar por comas, sumar, etc.

python
# media.txt: un número por línea
with open("media.txt", "r", encoding="utf-8") as archivo:
    numeros = [float(linea) for linea in archivo]

if numeros:
    print("Cantidad:", len(numeros))
    print("Suma:", sum(numeros))
    print("Media:", round(sum(numeros) / len(numeros), 2))

4. Escribir archivos ​

4.1. write(): escribir texto ​

write() escribe una cadena en el archivo y devuelve el número de caracteres escritos. No añade saltos de línea automáticamente: hay que incluirlos con \n.

python
with open("salida.txt", "w", encoding="utf-8") as archivo:
    archivo.write("Primera línea\n")
    archivo.write("Segunda línea\n")

4.2. Modo "a": añadir sin borrar ​

Con el modo "w" se destruye el contenido anterior. Para añadir información al final sin perder lo que había, se usa el modo "a":

python
with open("registro.txt", "a", encoding="utf-8") as archivo:
    archivo.write("Nueva entrada del registro\n")

Cada ejecución del programa añade una línea más.

4.3. Escribir varias líneas ​

writelines() recibe una lista de cadenas y las escribe en orden. Como write(), no añade saltos de línea: deben estar incluidos en cada cadena.

python
nombres = ["Ana\n", "Luis\n", "Marta\n"]

with open("nombres.txt", "w", encoding="utf-8") as archivo:
    archivo.writelines(nombres)

También se puede construir el texto completo y escribirlo de una vez con "\n".join(lista):

python
nombres = ["Ana", "Luis", "Marta"]
texto = "\n".join(nombres)

with open("nombres.txt", "w", encoding="utf-8") as archivo:
    archivo.write(texto)

5. Formatos estructurados: CSV y JSON ​

Los archivos de texto plano son cómodos, pero cuando los datos tienen estructura conviene usar formatos estándar que otros programas también entienden.

5.1. CSV: datos en filas y columnas ​

Un archivo CSV (Comma-Separated Values) guarda una tabla: cada línea es una fila y los valores se separan con comas (o punto y coma). Python incluye el módulo csv para leerlo y escribirlo sin preocuparse por las comillas o los separadores.

python
import csv

# Lectura
with open("notas.csv", "r", newline="", encoding="utf-8") as archivo:
    lector = csv.reader(archivo)
    for fila in lector:
        print(fila)          # cada fila es una lista de cadenas

# Escritura
filas = [
    ["nombre", "nota"],
    ["Ana", 8.5],
    ["Luis", 6.0],
    ["Marta", 9.25],
]

with open("notas.csv", "w", newline="", encoding="utf-8") as archivo:
    escritor = csv.writer(archivo)
    escritor.writerows(filas)

El argumento newline="" evita que se dupliquen los saltos de línea en algunos sistemas.

5.2. JSON: datos con estructura ​

JSON (JavaScript Object Notation) representa listas, diccionarios, números, cadenas y booleanos. Es el formato habitual para configuración e intercambio de datos. Se lee con json.load() y se escribe con json.dump().

python
import json

datos = {
    "nombre": "Ana",
    "curso": "1º Bachillerato",
    "notas": [8.5, 7.0, 9.25],
}

with open("datos.json", "w", encoding="utf-8") as archivo:
    json.dump(datos, archivo, ensure_ascii=False, indent=2)

with open("datos.json", "r", encoding="utf-8") as archivo:
    leidos = json.load(archivo)

print(leidos["nombre"])       # Ana
print(leidos["notas"][0])     # 8.5

ensure_ascii=False conserva tildes y eñes, e indent=2 genera un archivo legible con sangría.

5.3. ¿CSV o JSON? ​

CriterioCSVJSON
EstructuraTabla plana de filas y columnasÁrbol de listas y diccionarios
LegibilidadMuy alta en hojas de cálculoAlta para datos anidados
Tipos de datosTodo se lee como textoConserva números, booleanos, listas...
Uso típicoNotas, inventarios, exportacionesConfiguración, APIs, datos complejos

6. Errores y buenas prácticas ​

6.1. FileNotFoundError ​

Si intentamos leer un archivo que no existe en modo "r", Python lanza una excepción FileNotFoundError. Un programa robusto debe controlar esa situación:

python
try:
    with open("notas.txt", "r", encoding="utf-8") as archivo:
        print(archivo.read())
except FileNotFoundError:
    print("No se encontró el archivo notas.txt")

6.2. Comprobar si un archivo existe ​

El módulo os permite comprobar la existencia de una ruta antes de abrirla:

python
import os

ruta = "notas.txt"

if os.path.exists(ruta):
    with open(ruta, "r", encoding="utf-8") as archivo:
        print(archivo.read())
else:
    print("El archivo no existe")

6.3. Buenas prácticas ​

  • Usa siempre with para cerrar los archivos automáticamente.
  • Indica encoding="utf-8" al abrir archivos de texto.
  • No uses "w" si quieres conservar el contenido anterior: usa "a".
  • Comprueba con try/except los archivos que pueden no existir.
  • Cierra el archivo antes de que otro programa lo use.
  • No guardes contraseñas ni datos personales sensibles en archivos de texto plano.

7. Ejemplo integrador: agenda de contactos ​

python
# agenda.py
ARCHIVO = "agenda.txt"

def guardar_contacto(nombre, telefono):
    """Añade un contacto al final del archivo."""
    with open(ARCHIVO, "a", encoding="utf-8") as archivo:
        archivo.write(f"{nombre};{telefono}\n")

def mostrar_contactos():
    """Lee y muestra todos los contactos guardados."""
    try:
        with open(ARCHIVO, "r", encoding="utf-8") as archivo:
            for linea in archivo:
                nombre, telefono = linea.strip().split(";")
                print(f"{nombre}: {telefono}")
    except FileNotFoundError:
        print("Todavía no hay contactos guardados.")

guardar_contacto("Ana", "600111222")
guardar_contacto("Luis", "600333444")
mostrar_contactos()

Cada contacto se guarda en una línea con el formato nombre;telefono. Al leerlo, strip() elimina el salto de línea y split(";") separa los dos campos.


Ejercicios ​

  1. Función saludar. Define def saludar(nombre, lenguaje="Python"): que muestre "Hola <nombre>, estás aprendiendo <lenguaje>". Llámala con los dos argumentos, solo con el nombre y usando el nombre del parámetro lenguaje.

  2. Función con return. Escribe una función convertir_temperatura(valor, origen) que convierta Celsius a Fahrenheit (F = C * 9/5 + 32) y viceversa según si origen vale "C" o "F". Devuelve el resultado con return redondeado a un decimal y compruébalo con los valores 0, 37 y 100.

  3. Ámbito de variables. Predice qué imprime este fragmento y justifícalo mencionando los ámbitos local y global. Comprueba después ejecutándolo:

    python
    x = 5
    def funcion_a():
        x = 10
        print("A:", x)
    def funcion_b():
        print("B:", x)
    funcion_a()
    funcion_b()
    print("Global:", x)
  4. Módulo math. Escribe un programa que pida la base y la altura de un triángulo y muestre su área, la hipotenusa (math.sqrt) y el ángulo en grados del vértice superior respecto a la base usando math.degrees(math.atan(...)).

  5. Diario personal. Escribe un programa que pida frases al usuario hasta que escriba "fin" y las guarde en diario.txt en modo añadir ("a"). Después, abre el archivo y muestra su contenido numerando las líneas.

  6. Estadísticas de un archivo. Crea numeros.txt con un número por línea. Escribe una función estadisticas(ruta) que devuelva la suma, la media, el máximo y el mínimo de los valores. Controla con try/except el caso de que el archivo no exista.

  7. Contador de palabras. Lee un archivo de texto y muestra cuántas líneas, palabras y caracteres contiene. Usa strip() y split() para no contar los saltos de línea.

  8. Notas en CSV. Crea notas.csv con filas nombre,nota1,nota2. Escribe un programa que lea el archivo con el módulo csv, calcule la media de cada estudiante y guarde un nuevo archivo resultados.csv con las columnas nombre,media.

  9. Configuración en JSON. Guarda en config.json un diccionario con el nombre del usuario, el tema claro/oscuro y el tamaño de letra. Escribe una función cargar_config() que devuelva el diccionario y otra guardar_config(datos) que lo escriba con json.dump. Si el archivo no existe, usa valores por defecto.

Publicado bajo la licencia MIT.