Skip to article frontmatterSkip to article content
Site not loading correctly?

This may be due to an incorrect BASE_URL configuration. See the MyST Documentation for reference.

En casi cualquier lenguaje de programación, interactuar con archivos es fundamental. En Java y Go, esto se hace a través de librerías específicas (java.io, os), pero en Python es mucho más directo y expresivo.

1Representación de archivos y carpetas

En un sistema operativo (SO), un archivo es básicamente una secuencia de bytes almacenada en un medio físico (disco, SSD, memoria externa). Por lo general los archivos se encuentran en el disco dentro de un sistema de archivos o filesystem. Este sistema de archivo depende de cada sistema operativo. Por ejemplo Linux utiliza un sistema de archivos denominado ext4, mientras que Windows utiliza NTFS.

La principal diferencia entre distintos sistemas de archivos es como se gestionan los metadatos (información sobre el archivo, como su nombre, tamaño, permisos, etc.) y la estructura de directorios.

Archivo
Contiene datos (texto, imágenes, binarios, etc.).
Carpeta (o directorio)
Estructura que agrupa archivos y otras carpetas.

Para que una aplicación o programa pueda crear, leer o escribir un archivo o carpeta debe realizar una solicitud al SO, principal responsable de la gestión del hardware.

El SO responde a la petición con un descriptor de archivo (file descriptor_). Este descriptor de archivo es un número entero que identifica de manera única un archivo abierto en ese momento.

Mientras la aplicación tiene el archivo abierto, puede leer y escribir en él. Cuando la aplicación ya no necesita más el archivo debe cerrarlo. Al cerrar el archivo se notifica al SO que se terminó de utilizar y por lo tanto queda disponible para que otra aplicación o programa pueda manipularlo.

1.1Lectura y escritura

Cuando abrimos un archivo:

  1. El SO localiza el archivo y asigna un file descriptor.

  2. Python crea un objeto archivo que envuelve ese descriptor.

  3. Las operaciones de lectura/escritura se hacen en buffers (bloques de memoria intermedia) para optimizar el rendimiento.

Ejemplo: si quiere leer un archivo grande, Python no trae todo de golpe, sino trozos que se van entregando al programa. Lo mismo ocurre al escribir, en lugar de escribir todo de una vez, Python lo hace en partes.

Cuando se cierra un archivo en el que se escribieron datos, Python se asegura que todos los datos se hayan escrito correctamente en el disco, volcando toda la información de los buffers.

En este contexto es fundamental usar los bloques try/finally para garantizar que los archivos se cierren adecuadamente, incluso si ocurre un error durante la lectura o escritura. Como el bloque finally se ejecuta siempre, podemos asegurarnos de que el archivo se cierre en cualquier situación, incluso si hay excepciones, y que todos los datos escritos se guarden correctamente, liberando el archivo para su uso futuro o parte de otro programa.

1.2Archivos de texto vs archivos binarios

Texto
Interpretan bytes según una codificación (por ejemplo UTF-8).
Ejemplo: "hola" → 68 6f 6c 61 (bytes) interpretados como caracteres.
Binarios
Los bytes se usan tal cual (imágenes, ejecutables, audio, etc.).

En Python, esto se define al abrir el archivo con "t" (texto) o "b" (binario). En general si se omite el modo, se abrirá en modo texto.

1.3Saltos de línea: \n vs \r\n

En Linux y macOS los saltos de línea se representan con el caracter \n, mientras que en Windows se usan dos caracteres \r\n. Python traduce automáticamente al trabajar en modo texto, así que no hay que preocuparse si el programa se ejecuta en un entorno Windows, Linux o macOS, salvo que estemos manipulando el archivo en modo binario, donde es responsabilidad del programador.

2Operaciones con carpetas

Para manipular carpetas y rutas, Python ofrece los módulos os y pathlib.

2.1Rutas o paths absolutos y relativos

Path Absoluto
Especifica toda la ruta desde la raíz.
Por ejemplo: /home/usuario/archivo.txt o C:\Users\Usuario\archivo.txt
Path Relativo
Se interpreta desde el directorio donde se ejecuta el programa.
Por ejemplo: datos/archivo.txt

El caracter especial . representa el directorio actual, mientras que .. representa el directorio padre, con lo cual se pueden gestionar rutas relativas de manera más sencilla.

Algunas funciones útiles del módulo os para manipular archivos y carpetas son:

FunciónDescripciónEjemplo
os.getcwd()Obtiene el directorio de trabajo actual"/home/usuario/proyecto"
os.chdir(path)Cambia el directorio de trabajo actualos.chdir('/home/usuario/docs')
os.listdir(path)Lista archivos y carpetas en un directorio['archivo1.txt', 'carpeta1', 'imagen.png']
os.mkdir(path)Crea un directorioos.mkdir('nueva_carpeta')
os.makedirs(path)Crea directorios anidados (recursivo)os.makedirs('carpeta/subcarpeta')
os.rmdir(path)Elimina un directorio vacíoos.rmdir('carpeta_vacia')
os.removedirs(path)Elimina directorios vacíos recursivamenteos.removedirs('carpeta/subcarpeta')
os.remove(path)Elimina un archivoos.remove('archivo.txt')
os.rename(old, new)Renombra archivo o directorioos.rename('viejo.txt', 'nuevo.txt')
os.stat(path)Obtiene información del archivo (tamaño, permisos, etc.)os.stat('archivo.txt')
os.path.exists(path)Verifica si existe archivo o directorioTrue o False
os.path.isfile(path)Verifica si es un archivoTrue o False
os.path.isdir(path)Verifica si es un directorioTrue o False
os.path.join(...)Une partes de una ruta de forma portableos.path.join('carpeta', 'archivo.txt')
os.path.basename(path)Obtiene el nombre del archivo"archivo.txt" de "/ruta/archivo.txt"
os.path.dirname(path)Obtiene el directorio padre"/ruta" de "/ruta/archivo.txt"
os.path.splitext(path)Separa nombre y extensión('archivo', '.txt')
os.path.abspath(path)Convierte ruta relativa a absoluta"/home/usuario/archivo.txt"
os.path.getsize(path)Obtiene tamaño del archivo en bytes1024
import os

# Ejemplo práctico de uso
directorio_actual = os.getcwd()
print(f"Directorio actual: {directorio_actual}")

print("Archivos en directorio actual:")
for archivo in os.listdir("."):
    print(f"\t- {archivo}")

# Cambia al directorio temporal
os.chdir(tmp_dir)

# Crear estructura de carpetas
if not os.path.exists("datos"):
    os.makedirs("datos/procesados")
    print(f"Estructura de carpetas creada: " f"{os.path.abspath('datos/procesados')}")

# Trabajar con rutas
# Construir una ruta a un archivo.
# Se recomienda usar `os.path.join` y no concatenar cadenas ya que el módulo
# `os` puede construir rutas de forma portable para cualquier sistema
# operativo. Es decir este programa funcionará en cualquier sistema operativo
# sin modificaciones.
ruta_archivo = os.path.join("datos", "archivo.txt")

print(f"Ruta construida: {ruta_archivo}")
print(f"Ruta absoluta: {os.path.abspath(ruta_archivo)}")
print(f"¿Existe la ruta?: {os.path.exists(ruta_archivo)}")

os.chdir(directorio_actual)
Output
Directorio actual: /tmp/edd_archivos
Archivos en directorio actual:
Estructura de carpetas creada: /tmp/edd_archivos/datos/procesados
Ruta construida: datos/archivo.txt
Ruta absoluta: /tmp/edd_archivos/datos/archivo.txt
¿Existe la ruta?: False

2.2Módulo pathlib

Python 3.4+ incluye pathlib, que ofrece una interfaz más moderna y orientada a objetos:

Función/MétodoDescripciónEjemplo
Path.cwd()Directorio actualPath.cwd()
Path.home()Directorio home del usuarioPath.home()
Path.exists()Verifica existenciaPath('archivo.txt').exists()
Path.is_file()Verifica si es archivoPath('archivo.txt').is_file()
Path.is_dir()Verifica si es directorioPath('carpeta').is_dir()
Path.mkdir()Crea directorioPath('nueva').mkdir(parents=True)
Path.unlink()Elimina archivoPath('archivo.txt').unlink()
Path.rmdir()Elimina directorio vacíoPath('carpeta').rmdir()
Path.iterdir()Itera sobre contenidolist(Path('.').iterdir())
Path.glob(pattern)Busca archivos por patrónPath('.').glob('*.txt')
Path.chdir(path)Cambia el directorio actualPath.chdir('/nueva/ruta')
from pathlib import Path

# Ejemplo con pathlib (más pythónico)
directorio_actual = Path.cwd()
print(f"Directorio act: {directorio_actual}")

# Crear ruta de forma elegante
archivo = Path(tmp_dir) / "datos" / "ejemplo.txt"
print(f"Ruta del archivo: {archivo}")

# Crear directorio si no existe
archivo.parent.mkdir(parents=True, exist_ok=True)
print(f"Directorio creado: {archivo.parent}")

# Buscar archivos por patrón
archivos_md = list(Path(".").glob("**/*.md"))
print(f"Archivos Markdown encontrados: {len(archivos_md)}")
Output
Directorio act: /tmp/edd_archivos
Ruta del archivo: /tmp/edd_archivos/datos/ejemplo.txt
Directorio creado: /tmp/edd_archivos/datos
Archivos Markdown encontrados: 0

2.3“Caminar” por el sistema de archivos

os.walk() permite recorrer todas las carpetas y archivos a partir de una ubicación dada

import os
from datetime import datetime

# Ejemplo de uso de os.walk()
for raiz, dirs, archivos in os.walk("."):
    # Excluir directorios ocultos (como .ipynb_checkpoints)
    dirs[:] = [d for d in dirs if not d.startswith(".")]

    print(f"Carpeta: {raiz}")
    for archivo in archivos:
        if archivo.startswith("."):
            continue

        ruta_completa = os.path.join(raiz, archivo)

        # Obtener información del archivo
        try:
            info = os.stat(ruta_completa)

            print(f""" - {archivo}
       Ruta absoluta: {os.path.abspath(ruta_completa)}

       Tamaño: {info.st_size} bytes
       Última modificación: {datetime.fromtimestamp(info.st_mtime)}
       Permisos: {info.st_mode & 0o777:#o}
       Propietario: {info.st_uid}
       Grupo: {info.st_gid}
    """)
        except FileNotFoundError:
            print(f" - {archivo} (No encontrado)")
Output
Carpeta: .
Carpeta: ./datos
Carpeta: ./datos/procesados

3Operaciones básicas sobre archivos

3.1Apertura de archivos

La función básica para abrir archivos es open():

open(nombre, modo, encoding)
ModoSignificadoCrea archivo si no existeBorra contenido previo
"r"read (lectura)NoNo
"w"write (escritura)SiSi
"a"append (agregar)SiNo
"x"exclusive write (escritura exclusiva)Si-

El modo "x" es similar a "w", pero lanza una excepción si el archivo ya existe. Se usa para asegurarse que no estamos borrando el contenido de un archivo creado previamente.

El modo "a" permite agregar contenido al final del archivo sin borrar el contenido existente. Si el archivo no existe previamente, se crea.

Los modos de apertura de archivos por defecto abren los archivos como texto, si se trata de un archivo binario se debe especificar el modo "b". Por ejemplo: "rb" para lectura binaria o "wb" para escritura binaria.

help(open)
Output
Help on function open in module _io:

open(
    file,
    mode='r',
    buffering=-1,
    encoding=None,
    errors=None,
    newline=None,
    closefd=True,
    opener=None
)
    Open file and return a stream.  Raise OSError upon failure.

    file is either a text or byte string giving the name (and the path
    if the file isn't in the current working directory) of the file to
    be opened or an integer file descriptor of the file to be
    wrapped. (If a file descriptor is given, it is closed when the
    returned I/O object is closed, unless closefd is set to False.)

    mode is an optional string that specifies the mode in which the file
    is opened. It defaults to 'r' which means open for reading in text
    mode.  Other common values are 'w' for writing (truncating the file if
    it already exists), 'x' for creating and writing to a new file, and
    'a' for appending (which on some Unix systems, means that all writes
    append to the end of the file regardless of the current seek position).
    In text mode, if encoding is not specified the encoding used is platform
    dependent: locale.getencoding() is called to get the current locale encoding.
    (For reading and writing raw bytes use binary mode and leave encoding
    unspecified.) The available modes are:

    ========= ===============================================================
    Character Meaning
    --------- ---------------------------------------------------------------
    'r'       open for reading (default)
    'w'       open for writing, truncating the file first
    'x'       create a new file and open it for writing
    'a'       open for writing, appending to the end of the file if it exists
    'b'       binary mode
    't'       text mode (default)
    '+'       open a disk file for updating (reading and writing)
    ========= ===============================================================

    The default mode is 'rt' (open for reading text). For binary random
    access, the mode 'w+b' opens and truncates the file to 0 bytes, while
    'r+b' opens the file without truncation. The 'x' mode implies 'w' and
    raises an `FileExistsError` if the file already exists.

    Python distinguishes between files opened in binary and text modes,
    even when the underlying operating system doesn't. Files opened in
    binary mode (appending 'b' to the mode argument) return contents as
    bytes objects without any decoding. In text mode (the default, or when
    't' is appended to the mode argument), the contents of the file are
    returned as strings, the bytes having been first decoded using a
    platform-dependent encoding or using the specified encoding if given.

    buffering is an optional integer used to set the buffering policy.
    Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
    line buffering (only usable in text mode), and an integer > 1 to indicate
    the size of a fixed-size chunk buffer.  When no buffering argument is
    given, the default buffering policy works as follows:

    * Binary files are buffered in fixed-size chunks; the size of the buffer
      is chosen using a heuristic trying to determine the underlying device's
      "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
      On many systems, the buffer will typically be 4096 or 8192 bytes long.

    * "Interactive" text files (files for which isatty() returns True)
      use line buffering.  Other text files use the policy described above
      for binary files.

    encoding is the name of the encoding used to decode or encode the
    file. This should only be used in text mode. The default encoding is
    platform dependent, but any encoding supported by Python can be
    passed.  See the codecs module for the list of supported encodings.

    errors is an optional string that specifies how encoding errors are to
    be handled---this argument should not be used in binary mode. Pass
    'strict' to raise a ValueError exception if there is an encoding error
    (the default of None has the same effect), or pass 'ignore' to ignore
    errors. (Note that ignoring encoding errors can lead to data loss.)
    See the documentation for codecs.register or run 'help(codecs.Codec)'
    for a list of the permitted encoding error strings.

    newline controls how universal newlines works (it only applies to text
    mode). It can be None, '', '\n', '\r', and '\r\n'.  It works as
    follows:

    * On input, if newline is None, universal newlines mode is
      enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
      these are translated into '\n' before being returned to the
      caller. If it is '', universal newline mode is enabled, but line
      endings are returned to the caller untranslated. If it has any of
      the other legal values, input lines are only terminated by the given
      string, and the line ending is returned to the caller untranslated.

    * On output, if newline is None, any '\n' characters written are
      translated to the system default line separator, os.linesep. If
      newline is '' or '\n', no translation takes place. If newline is any
      of the other legal values, any '\n' characters written are translated
      to the given string.

    If closefd is False, the underlying file descriptor will be kept open
    when the file is closed. This does not work when a file name is given
    and must be True in that case.

    A custom opener can be used by passing a callable as *opener*. The
    underlying file descriptor for the file object is then obtained by
    calling *opener* with (*file*, *flags*). *opener* must return an open
    file descriptor (passing os.open as *opener* results in functionality
    similar to passing None).

    open() returns a file object whose type depends on the mode, and
    through which the standard file operations such as reading and writing
    are performed. When open() is used to open a file in a text mode ('w',
    'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
    a file in a binary mode, the returned class varies: in read binary
    mode, it returns a BufferedReader; in write binary and append binary
    modes, it returns a BufferedWriter, and in read/write mode, it returns
    a BufferedRandom.

    It is also possible to use a string or bytearray as a file for both
    reading and writing. For strings StringIO can be used like a file
    opened in a text mode, and for bytes a BytesIO can be used like a file
    opened in a binary mode.

3.2Lectura de archivos

Una vez abierto un archivo hay varias formas de leerlo, se puede leer completamente y cargarlo en memoria, o leerlo línea por línea, o posicionar el cursor en una parte específica del archivo para leer desde allí la cantidad de caracteres deseada, etc.

El archivo de texto que vamos a usar de prueba tiene texto en castellano y en chino tradicional, con caracteres especiales.

Leer todo el documento en una variable

archivo = os.path.join(original_cwd, "../_static/code/archivos/edd.txt")

try:
    f = open(archivo, "r", encoding="utf-8")  # Puede levantar FileNotFoundError
except FileNotFoundError:
    print("Archivo no encontrado")
else:
    try:
        contenido = f.read()  # Puede levantar otras excepciones
        print(contenido)
    except Exception as e:
        print(f"Error inesperado: {e}")
    finally:
        f.close()
Output
Estructuras de datos
Fundamentos de la asignatura
Esta asignatura se centra en proporcionar a los estudiantes conocimientos sobre la búsqueda y recuperación de información, así como en las estructuras de datos necesarias para almacenarla y manipularla. El constante y creciente volumen de información publicada en internet y en redes sociales, junto con la necesidad de procesarla y analizarla para extraer conocimiento valioso, es la principal motivación para explorar esta disciplina, que se considera precursora de la ciencia de datos y base fundamental para el desarrollo de aplicaciones inteligentes y sistemas de toma de decisiones basados en datos.
El estudio de las estructuras de datos y los algoritmos de búsqueda y recuperación de información es esencial para comprender cómo se organizan y manipulan los datos en una amplia gama de aplicaciones, desde sistemas de bases de datos y motores de búsqueda, hasta redes sociales y plataformas de comercio electrónico. Además, proporciona a los estudiantes las herramientas y habilidades necesarias para diseñar e implementar soluciones eficientes y escalables para problemas del mundo real que involucran grandes volúmenes de datos, sentando las bases para una comprensión profunda de la ciencia de datos y sus aplicaciones en diversos campos y disciplinas.
Objetivo general
Comprender y aplicar los principios fundamentales de las estructuras de datos y los algoritmos de búsqueda y recuperación de información, con énfasis en su relevancia para el manejo eficiente de grandes volúmenes de datos y su aplicación en la ciencia de datos y el desarrollo de sistemas inteligentes.
Objetivos específicos
Al finalizar la materia los alumnos serán capaces de:
Reconocer la problemática del manejo de grandes volúmenes de información y la necesidad de estructuras de datos y algoritmos eficientes para su procesamiento y análisis.
Estudiar, implementar y comparar el rendimiento de diferentes estructuras de datos relevantes para la búsqueda y recuperación de información.
Comprender cómo las estructuras de datos y los algoritmos estudiados son fundamentales para el desarrollo de aplicaciones de ciencia de datos, como motores de búsqueda, sistemas de recomendación y análisis de redes sociales.
Seleccionar y adaptar las estructuras de datos y algoritmos adecuados para resolver problemas específicos relacionados con el manejo y análisis de grandes volúmenes de datos.
Comprender en profundidad los conceptos de organización de datos y registros de información, analizando diversas formas de representación y almacenamiento.


資料結構
學科基礎
本課程致力於為學生提供資訊搜尋和檢索的知識，以及儲存和操作資訊所需的資料結構。網路和社群媒體上不斷增長的資訊量，以及對其進行處理和分析以提取有價值知識的需求，是探索該學科的主要動機。該學科被認為是數據科學的先驅，也是開發智慧應用程式和數據驅動決策系統的基礎。
資料結構以及資訊搜尋和檢索演算法的研究對於理解從資料庫系統、搜尋引擎到社交媒體和電商平台等各種應用中資料的組織和操作方式至關重要。此外，本課程也為學生提供設計和實施高效、可擴展的大量資料解決方案所需的工具和技能，為深入理解資料科學及其在各個領域和學科的應用奠定基礎。
整體目標
理解並應用資料結構和資訊搜尋與檢索演算法的基本原理，重點關注其與高效管理海量資料及其在資料科學和智慧系統開發中的應用。
具體目標
完成本課程後，學生將能夠：
認識到管理海量資訊的問題，以及對高效資料結構和演算法進行處理和分析的需求。
學習、實現並比較與資訊搜尋和檢索相關的不同資料結構的效能。
理解所研究的資料結構和演算法如何成為資料科學應用（例如搜尋引擎、推薦系統和社交網路分析）開發的基礎。
選擇並調整合適的資料結構和演算法來解決與海量資料管理和分析相關的具體問題。
深入了解資料組織和資訊記錄的概念，分析各種表示和儲存形式。

Leer línea por línea en una lista

archivo = os.path.join(original_cwd, "../_static/code/archivos/edd.txt")

try:
    f = open(archivo, "r", encoding="utf-8")  # Puede levantar FileNotFoundError
except FileNotFoundError:
    print("Archivo no encontrado")
else:
    try:
        contenido = f.readlines()  # Puede levantar otras excepciones
        print(contenido)
    except Exception as e:
        print(f"Error inesperado: {e}")
    finally:
        f.close()
Output
['Estructuras de datos\n', 'Fundamentos de la asignatura\n', 'Esta asignatura se centra en proporcionar a los estudiantes conocimientos sobre la búsqueda y recuperación de información, así como en las estructuras de datos necesarias para almacenarla y manipularla. El constante y creciente volumen de información publicada en internet y en redes sociales, junto con la necesidad de procesarla y analizarla para extraer conocimiento valioso, es la principal motivación para explorar esta disciplina, que se considera precursora de la ciencia de datos y base fundamental para el desarrollo de aplicaciones inteligentes y sistemas de toma de decisiones basados en datos.\n', 'El estudio de las estructuras de datos y los algoritmos de búsqueda y recuperación de información es esencial para comprender cómo se organizan y manipulan los datos en una amplia gama de aplicaciones, desde sistemas de bases de datos y motores de búsqueda, hasta redes sociales y plataformas de comercio electrónico. Además, proporciona a los estudiantes las herramientas y habilidades necesarias para diseñar e implementar soluciones eficientes y escalables para problemas del mundo real que involucran grandes volúmenes de datos, sentando las bases para una comprensión profunda de la ciencia de datos y sus aplicaciones en diversos campos y disciplinas.\n', 'Objetivo general\n', 'Comprender y aplicar los principios fundamentales de las estructuras de datos y los algoritmos de búsqueda y recuperación de información, con énfasis en su relevancia para el manejo eficiente de grandes volúmenes de datos y su aplicación en la ciencia de datos y el desarrollo de sistemas inteligentes.\n', 'Objetivos específicos\n', 'Al finalizar la materia los alumnos serán capaces de:\n', 'Reconocer la problemática del manejo de grandes volúmenes de información y la necesidad de estructuras de datos y algoritmos eficientes para su procesamiento y análisis.\n', 'Estudiar, implementar y comparar el rendimiento de diferentes estructuras de datos relevantes para la búsqueda y recuperación de información.\n', 'Comprender cómo las estructuras de datos y los algoritmos estudiados son fundamentales para el desarrollo de aplicaciones de ciencia de datos, como motores de búsqueda, sistemas de recomendación y análisis de redes sociales.\n', 'Seleccionar y adaptar las estructuras de datos y algoritmos adecuados para resolver problemas específicos relacionados con el manejo y análisis de grandes volúmenes de datos.\n', 'Comprender en profundidad los conceptos de organización de datos y registros de información, analizando diversas formas de representación y almacenamiento.\n', '\n', '\n', '資料結構\n', '學科基礎\n', '本課程致力於為學生提供資訊搜尋和檢索的知識，以及儲存和操作資訊所需的資料結構。網路和社群媒體上不斷增長的資訊量，以及對其進行處理和分析以提取有價值知識的需求，是探索該學科的主要動機。該學科被認為是數據科學的先驅，也是開發智慧應用程式和數據驅動決策系統的基礎。\n', '資料結構以及資訊搜尋和檢索演算法的研究對於理解從資料庫系統、搜尋引擎到社交媒體和電商平台等各種應用中資料的組織和操作方式至關重要。此外，本課程也為學生提供設計和實施高效、可擴展的大量資料解決方案所需的工具和技能，為深入理解資料科學及其在各個領域和學科的應用奠定基礎。\n', '整體目標\n', '理解並應用資料結構和資訊搜尋與檢索演算法的基本原理，重點關注其與高效管理海量資料及其在資料科學和智慧系統開發中的應用。\n', '具體目標\n', '完成本課程後，學生將能夠：\n', '認識到管理海量資訊的問題，以及對高效資料結構和演算法進行處理和分析的需求。\n', '學習、實現並比較與資訊搜尋和檢索相關的不同資料結構的效能。\n', '理解所研究的資料結構和演算法如何成為資料科學應用（例如搜尋引擎、推薦系統和社交網路分析）開發的基礎。\n', '選擇並調整合適的資料結構和演算法來解決與海量資料管理和分析相關的具體問題。\n', '深入了解資料組織和資訊記錄的概念，分析各種表示和儲存形式。\n']

Iterar línea por línea

Iterando con while
archivo = os.path.join(original_cwd, "../_static/code/archivos/edd.txt")

try:
    f = open(archivo, "r", encoding="utf-8")  # Puede levantar FileNotFoundError
except FileNotFoundError:
    print("Archivo no encontrado")
else:
    try:
        while linea := f.readline():
            print(linea)
    except Exception as e:
        print(f"Error inesperado: {e}")
    finally:
        f.close()
Output
Estructuras de datos

Fundamentos de la asignatura

Esta asignatura se centra en proporcionar a los estudiantes conocimientos sobre la búsqueda y recuperación de información, así como en las estructuras de datos necesarias para almacenarla y manipularla. El constante y creciente volumen de información publicada en internet y en redes sociales, junto con la necesidad de procesarla y analizarla para extraer conocimiento valioso, es la principal motivación para explorar esta disciplina, que se considera precursora de la ciencia de datos y base fundamental para el desarrollo de aplicaciones inteligentes y sistemas de toma de decisiones basados en datos.

El estudio de las estructuras de datos y los algoritmos de búsqueda y recuperación de información es esencial para comprender cómo se organizan y manipulan los datos en una amplia gama de aplicaciones, desde sistemas de bases de datos y motores de búsqueda, hasta redes sociales y plataformas de comercio electrónico. Además, proporciona a los estudiantes las herramientas y habilidades necesarias para diseñar e implementar soluciones eficientes y escalables para problemas del mundo real que involucran grandes volúmenes de datos, sentando las bases para una comprensión profunda de la ciencia de datos y sus aplicaciones en diversos campos y disciplinas.

Objetivo general

Comprender y aplicar los principios fundamentales de las estructuras de datos y los algoritmos de búsqueda y recuperación de información, con énfasis en su relevancia para el manejo eficiente de grandes volúmenes de datos y su aplicación en la ciencia de datos y el desarrollo de sistemas inteligentes.

Objetivos específicos

Al finalizar la materia los alumnos serán capaces de:

Reconocer la problemática del manejo de grandes volúmenes de información y la necesidad de estructuras de datos y algoritmos eficientes para su procesamiento y análisis.

Estudiar, implementar y comparar el rendimiento de diferentes estructuras de datos relevantes para la búsqueda y recuperación de información.

Comprender cómo las estructuras de datos y los algoritmos estudiados son fundamentales para el desarrollo de aplicaciones de ciencia de datos, como motores de búsqueda, sistemas de recomendación y análisis de redes sociales.

Seleccionar y adaptar las estructuras de datos y algoritmos adecuados para resolver problemas específicos relacionados con el manejo y análisis de grandes volúmenes de datos.

Comprender en profundidad los conceptos de organización de datos y registros de información, analizando diversas formas de representación y almacenamiento.





資料結構

學科基礎

本課程致力於為學生提供資訊搜尋和檢索的知識，以及儲存和操作資訊所需的資料結構。網路和社群媒體上不斷增長的資訊量，以及對其進行處理和分析以提取有價值知識的需求，是探索該學科的主要動機。該學科被認為是數據科學的先驅，也是開發智慧應用程式和數據驅動決策系統的基礎。

資料結構以及資訊搜尋和檢索演算法的研究對於理解從資料庫系統、搜尋引擎到社交媒體和電商平台等各種應用中資料的組織和操作方式至關重要。此外，本課程也為學生提供設計和實施高效、可擴展的大量資料解決方案所需的工具和技能，為深入理解資料科學及其在各個領域和學科的應用奠定基礎。

整體目標

理解並應用資料結構和資訊搜尋與檢索演算法的基本原理，重點關注其與高效管理海量資料及其在資料科學和智慧系統開發中的應用。

具體目標

完成本課程後，學生將能夠：

認識到管理海量資訊的問題，以及對高效資料結構和演算法進行處理和分析的需求。

學習、實現並比較與資訊搜尋和檢索相關的不同資料結構的效能。

理解所研究的資料結構和演算法如何成為資料科學應用（例如搜尋引擎、推薦系統和社交網路分析）開發的基礎。

選擇並調整合適的資料結構和演算法來解決與海量資料管理和分析相關的具體問題。

深入了解資料組織和資訊記錄的概念，分析各種表示和儲存形式。
Iterando con for
archivo = os.path.join(original_cwd, "../_static/code/archivos/edd.txt")

try:
    f = open(archivo, "r", encoding="utf-8")  # Puede levantar FileNotFoundError
except FileNotFoundError:
    print("Archivo no encontrado")
else:
    try:
        for linea in f:
            print(linea)
    except Exception as e:
        print(f"Error inesperado: {e}")
    finally:
        f.close()
Output
Estructuras de datos

Fundamentos de la asignatura

Esta asignatura se centra en proporcionar a los estudiantes conocimientos sobre la búsqueda y recuperación de información, así como en las estructuras de datos necesarias para almacenarla y manipularla. El constante y creciente volumen de información publicada en internet y en redes sociales, junto con la necesidad de procesarla y analizarla para extraer conocimiento valioso, es la principal motivación para explorar esta disciplina, que se considera precursora de la ciencia de datos y base fundamental para el desarrollo de aplicaciones inteligentes y sistemas de toma de decisiones basados en datos.

El estudio de las estructuras de datos y los algoritmos de búsqueda y recuperación de información es esencial para comprender cómo se organizan y manipulan los datos en una amplia gama de aplicaciones, desde sistemas de bases de datos y motores de búsqueda, hasta redes sociales y plataformas de comercio electrónico. Además, proporciona a los estudiantes las herramientas y habilidades necesarias para diseñar e implementar soluciones eficientes y escalables para problemas del mundo real que involucran grandes volúmenes de datos, sentando las bases para una comprensión profunda de la ciencia de datos y sus aplicaciones en diversos campos y disciplinas.

Objetivo general

Comprender y aplicar los principios fundamentales de las estructuras de datos y los algoritmos de búsqueda y recuperación de información, con énfasis en su relevancia para el manejo eficiente de grandes volúmenes de datos y su aplicación en la ciencia de datos y el desarrollo de sistemas inteligentes.

Objetivos específicos

Al finalizar la materia los alumnos serán capaces de:

Reconocer la problemática del manejo de grandes volúmenes de información y la necesidad de estructuras de datos y algoritmos eficientes para su procesamiento y análisis.

Estudiar, implementar y comparar el rendimiento de diferentes estructuras de datos relevantes para la búsqueda y recuperación de información.

Comprender cómo las estructuras de datos y los algoritmos estudiados son fundamentales para el desarrollo de aplicaciones de ciencia de datos, como motores de búsqueda, sistemas de recomendación y análisis de redes sociales.

Seleccionar y adaptar las estructuras de datos y algoritmos adecuados para resolver problemas específicos relacionados con el manejo y análisis de grandes volúmenes de datos.

Comprender en profundidad los conceptos de organización de datos y registros de información, analizando diversas formas de representación y almacenamiento.





資料結構

學科基礎

本課程致力於為學生提供資訊搜尋和檢索的知識，以及儲存和操作資訊所需的資料結構。網路和社群媒體上不斷增長的資訊量，以及對其進行處理和分析以提取有價值知識的需求，是探索該學科的主要動機。該學科被認為是數據科學的先驅，也是開發智慧應用程式和數據驅動決策系統的基礎。

資料結構以及資訊搜尋和檢索演算法的研究對於理解從資料庫系統、搜尋引擎到社交媒體和電商平台等各種應用中資料的組織和操作方式至關重要。此外，本課程也為學生提供設計和實施高效、可擴展的大量資料解決方案所需的工具和技能，為深入理解資料科學及其在各個領域和學科的應用奠定基礎。

整體目標

理解並應用資料結構和資訊搜尋與檢索演算法的基本原理，重點關注其與高效管理海量資料及其在資料科學和智慧系統開發中的應用。

具體目標

完成本課程後，學生將能夠：

認識到管理海量資訊的問題，以及對高效資料結構和演算法進行處理和分析的需求。

學習、實現並比較與資訊搜尋和檢索相關的不同資料結構的效能。

理解所研究的資料結構和演算法如何成為資料科學應用（例如搜尋引擎、推薦系統和社交網路分析）開發的基礎。

選擇並調整合適的資料結構和演算法來解決與海量資料管理和分析相關的具體問題。

深入了解資料組織和資訊記錄的概念，分析各種表示和儲存形式。

Leer una porción específica del archivo

archivo = os.path.join(original_cwd, "../_static/code/archivos/edd.txt")

try:
    f = open(archivo, "r", encoding="utf-8")  # Puede levantar FileNotFoundError
except FileNotFoundError:
    print("Archivo no encontrado")
else:
    try:
        f.seek(100)  # Posicionar el cursor en el caracter 100
        print("Leer desde la posición 100\n")
        print(f.read(100))  # Leer 100 caracteres a partir de la posición 100
        print("\nLeer desde el inicio\n")
        f.seek(0)  # Volver al inicio del archivo
        print(f.read(100))  # Leer 100 caracteres desde el inicio
    except Exception as e:
        print(f"Error inesperado: {e}")
    finally:
        f.close()
Output
Leer desde la posición 100

tudiantes conocimientos sobre la búsqueda y recuperación de información, así como en las estructuras

Leer desde el inicio

Estructuras de datos
Fundamentos de la asignatura
Esta asignatura se centra en proporcionar a los es

Leer un archivo binario

Si leemos el mismo archivo de texto pero en formato binario veremos dígitos en hexadecimal que se usan para representar los caracteres especiales.

archivo = os.path.join(original_cwd, "../_static/code/archivos/edd.txt")

try:
    f = open(archivo, "rb")  # Puede levantar FileNotFoundError
except FileNotFoundError:
    print("Archivo no encontrado")
else:
    try:
        contenido = f.read()  # Puede levantar otras excepciones
        print(contenido)
    except Exception as e:
        print(f"Error inesperado: {e}")
    finally:
        f.close()
Output
b'Estructuras de datos\nFundamentos de la asignatura\nEsta asignatura se centra en proporcionar a los estudiantes conocimientos sobre la b\xc3\xbasqueda y recuperaci\xc3\xb3n de informaci\xc3\xb3n, as\xc3\xad como en las estructuras de datos necesarias para almacenarla y manipularla. El constante y creciente volumen de informaci\xc3\xb3n publicada en internet y en redes sociales, junto con la necesidad de procesarla y analizarla para extraer conocimiento valioso, es la principal motivaci\xc3\xb3n para explorar esta disciplina, que se considera precursora de la ciencia de datos y base fundamental para el desarrollo de aplicaciones inteligentes y sistemas de toma de decisiones basados en datos.\nEl estudio de las estructuras de datos y los algoritmos de b\xc3\xbasqueda y recuperaci\xc3\xb3n de informaci\xc3\xb3n es esencial para comprender c\xc3\xb3mo se organizan y manipulan los datos en una amplia gama de aplicaciones, desde sistemas de bases de datos y motores de b\xc3\xbasqueda, hasta redes sociales y plataformas de comercio electr\xc3\xb3nico. Adem\xc3\xa1s, proporciona a los estudiantes las herramientas y habilidades necesarias para dise\xc3\xb1ar e implementar soluciones eficientes y escalables para problemas del mundo real que involucran grandes vol\xc3\xbamenes de datos, sentando las bases para una comprensi\xc3\xb3n profunda de la ciencia de datos y sus aplicaciones en diversos campos y disciplinas.\nObjetivo general\nComprender y aplicar los principios fundamentales de las estructuras de datos y los algoritmos de b\xc3\xbasqueda y recuperaci\xc3\xb3n de informaci\xc3\xb3n, con \xc3\xa9nfasis en su relevancia para el manejo eficiente de grandes vol\xc3\xbamenes de datos y su aplicaci\xc3\xb3n en la ciencia de datos y el desarrollo de sistemas inteligentes.\nObjetivos espec\xc3\xadficos\nAl finalizar la materia los alumnos ser\xc3\xa1n capaces de:\nReconocer la problem\xc3\xa1tica del manejo de grandes vol\xc3\xbamenes de informaci\xc3\xb3n y la necesidad de estructuras de datos y algoritmos eficientes para su procesamiento y an\xc3\xa1lisis.\nEstudiar, implementar y comparar el rendimiento de diferentes estructuras de datos relevantes para la b\xc3\xbasqueda y recuperaci\xc3\xb3n de informaci\xc3\xb3n.\nComprender c\xc3\xb3mo las estructuras de datos y los algoritmos estudiados son fundamentales para el desarrollo de aplicaciones de ciencia de datos, como motores de b\xc3\xbasqueda, sistemas de recomendaci\xc3\xb3n y an\xc3\xa1lisis de redes sociales.\nSeleccionar y adaptar las estructuras de datos y algoritmos adecuados para resolver problemas espec\xc3\xadficos relacionados con el manejo y an\xc3\xa1lisis de grandes vol\xc3\xbamenes de datos.\nComprender en profundidad los conceptos de organizaci\xc3\xb3n de datos y registros de informaci\xc3\xb3n, analizando diversas formas de representaci\xc3\xb3n y almacenamiento.\n\n\n\xe8\xb3\x87\xe6\x96\x99\xe7\xb5\x90\xe6\xa7\x8b\n\xe5\xad\xb8\xe7\xa7\x91\xe5\x9f\xba\xe7\xa4\x8e\n\xe6\x9c\xac\xe8\xaa\xb2\xe7\xa8\x8b\xe8\x87\xb4\xe5\x8a\x9b\xe6\x96\xbc\xe7\x82\xba\xe5\xad\xb8\xe7\x94\x9f\xe6\x8f\x90\xe4\xbe\x9b\xe8\xb3\x87\xe8\xa8\x8a\xe6\x90\x9c\xe5\xb0\x8b\xe5\x92\x8c\xe6\xaa\xa2\xe7\xb4\xa2\xe7\x9a\x84\xe7\x9f\xa5\xe8\xad\x98\xef\xbc\x8c\xe4\xbb\xa5\xe5\x8f\x8a\xe5\x84\xb2\xe5\xad\x98\xe5\x92\x8c\xe6\x93\x8d\xe4\xbd\x9c\xe8\xb3\x87\xe8\xa8\x8a\xe6\x89\x80\xe9\x9c\x80\xe7\x9a\x84\xe8\xb3\x87\xe6\x96\x99\xe7\xb5\x90\xe6\xa7\x8b\xe3\x80\x82\xe7\xb6\xb2\xe8\xb7\xaf\xe5\x92\x8c\xe7\xa4\xbe\xe7\xbe\xa4\xe5\xaa\x92\xe9\xab\x94\xe4\xb8\x8a\xe4\xb8\x8d\xe6\x96\xb7\xe5\xa2\x9e\xe9\x95\xb7\xe7\x9a\x84\xe8\xb3\x87\xe8\xa8\x8a\xe9\x87\x8f\xef\xbc\x8c\xe4\xbb\xa5\xe5\x8f\x8a\xe5\xb0\x8d\xe5\x85\xb6\xe9\x80\xb2\xe8\xa1\x8c\xe8\x99\x95\xe7\x90\x86\xe5\x92\x8c\xe5\x88\x86\xe6\x9e\x90\xe4\xbb\xa5\xe6\x8f\x90\xe5\x8f\x96\xe6\x9c\x89\xe5\x83\xb9\xe5\x80\xbc\xe7\x9f\xa5\xe8\xad\x98\xe7\x9a\x84\xe9\x9c\x80\xe6\xb1\x82\xef\xbc\x8c\xe6\x98\xaf\xe6\x8e\xa2\xe7\xb4\xa2\xe8\xa9\xb2\xe5\xad\xb8\xe7\xa7\x91\xe7\x9a\x84\xe4\xb8\xbb\xe8\xa6\x81\xe5\x8b\x95\xe6\xa9\x9f\xe3\x80\x82\xe8\xa9\xb2\xe5\xad\xb8\xe7\xa7\x91\xe8\xa2\xab\xe8\xaa\x8d\xe7\x82\xba\xe6\x98\xaf\xe6\x95\xb8\xe6\x93\x9a\xe7\xa7\x91\xe5\xad\xb8\xe7\x9a\x84\xe5\x85\x88\xe9\xa9\x85\xef\xbc\x8c\xe4\xb9\x9f\xe6\x98\xaf\xe9\x96\x8b\xe7\x99\xbc\xe6\x99\xba\xe6\x85\xa7\xe6\x87\x89\xe7\x94\xa8\xe7\xa8\x8b\xe5\xbc\x8f\xe5\x92\x8c\xe6\x95\xb8\xe6\x93\x9a\xe9\xa9\x85\xe5\x8b\x95\xe6\xb1\xba\xe7\xad\x96\xe7\xb3\xbb\xe7\xb5\xb1\xe7\x9a\x84\xe5\x9f\xba\xe7\xa4\x8e\xe3\x80\x82\n\xe8\xb3\x87\xe6\x96\x99\xe7\xb5\x90\xe6\xa7\x8b\xe4\xbb\xa5\xe5\x8f\x8a\xe8\xb3\x87\xe8\xa8\x8a\xe6\x90\x9c\xe5\xb0\x8b\xe5\x92\x8c\xe6\xaa\xa2\xe7\xb4\xa2\xe6\xbc\x94\xe7\xae\x97\xe6\xb3\x95\xe7\x9a\x84\xe7\xa0\x94\xe7\xa9\xb6\xe5\xb0\x8d\xe6\x96\xbc\xe7\x90\x86\xe8\xa7\xa3\xe5\xbe\x9e\xe8\xb3\x87\xe6\x96\x99\xe5\xba\xab\xe7\xb3\xbb\xe7\xb5\xb1\xe3\x80\x81\xe6\x90\x9c\xe5\xb0\x8b\xe5\xbc\x95\xe6\x93\x8e\xe5\x88\xb0\xe7\xa4\xbe\xe4\xba\xa4\xe5\xaa\x92\xe9\xab\x94\xe5\x92\x8c\xe9\x9b\xbb\xe5\x95\x86\xe5\xb9\xb3\xe5\x8f\xb0\xe7\xad\x89\xe5\x90\x84\xe7\xa8\xae\xe6\x87\x89\xe7\x94\xa8\xe4\xb8\xad\xe8\xb3\x87\xe6\x96\x99\xe7\x9a\x84\xe7\xb5\x84\xe7\xb9\x94\xe5\x92\x8c\xe6\x93\x8d\xe4\xbd\x9c\xe6\x96\xb9\xe5\xbc\x8f\xe8\x87\xb3\xe9\x97\x9c\xe9\x87\x8d\xe8\xa6\x81\xe3\x80\x82\xe6\xad\xa4\xe5\xa4\x96\xef\xbc\x8c\xe6\x9c\xac\xe8\xaa\xb2\xe7\xa8\x8b\xe4\xb9\x9f\xe7\x82\xba\xe5\xad\xb8\xe7\x94\x9f\xe6\x8f\x90\xe4\xbe\x9b\xe8\xa8\xad\xe8\xa8\x88\xe5\x92\x8c\xe5\xaf\xa6\xe6\x96\xbd\xe9\xab\x98\xe6\x95\x88\xe3\x80\x81\xe5\x8f\xaf\xe6\x93\xb4\xe5\xb1\x95\xe7\x9a\x84\xe5\xa4\xa7\xe9\x87\x8f\xe8\xb3\x87\xe6\x96\x99\xe8\xa7\xa3\xe6\xb1\xba\xe6\x96\xb9\xe6\xa1\x88\xe6\x89\x80\xe9\x9c\x80\xe7\x9a\x84\xe5\xb7\xa5\xe5\x85\xb7\xe5\x92\x8c\xe6\x8a\x80\xe8\x83\xbd\xef\xbc\x8c\xe7\x82\xba\xe6\xb7\xb1\xe5\x85\xa5\xe7\x90\x86\xe8\xa7\xa3\xe8\xb3\x87\xe6\x96\x99\xe7\xa7\x91\xe5\xad\xb8\xe5\x8f\x8a\xe5\x85\xb6\xe5\x9c\xa8\xe5\x90\x84\xe5\x80\x8b\xe9\xa0\x98\xe5\x9f\x9f\xe5\x92\x8c\xe5\xad\xb8\xe7\xa7\x91\xe7\x9a\x84\xe6\x87\x89\xe7\x94\xa8\xe5\xa5\xa0\xe5\xae\x9a\xe5\x9f\xba\xe7\xa4\x8e\xe3\x80\x82\n\xe6\x95\xb4\xe9\xab\x94\xe7\x9b\xae\xe6\xa8\x99\n\xe7\x90\x86\xe8\xa7\xa3\xe4\xb8\xa6\xe6\x87\x89\xe7\x94\xa8\xe8\xb3\x87\xe6\x96\x99\xe7\xb5\x90\xe6\xa7\x8b\xe5\x92\x8c\xe8\xb3\x87\xe8\xa8\x8a\xe6\x90\x9c\xe5\xb0\x8b\xe8\x88\x87\xe6\xaa\xa2\xe7\xb4\xa2\xe6\xbc\x94\xe7\xae\x97\xe6\xb3\x95\xe7\x9a\x84\xe5\x9f\xba\xe6\x9c\xac\xe5\x8e\x9f\xe7\x90\x86\xef\xbc\x8c\xe9\x87\x8d\xe9\xbb\x9e\xe9\x97\x9c\xe6\xb3\xa8\xe5\x85\xb6\xe8\x88\x87\xe9\xab\x98\xe6\x95\x88\xe7\xae\xa1\xe7\x90\x86\xe6\xb5\xb7\xe9\x87\x8f\xe8\xb3\x87\xe6\x96\x99\xe5\x8f\x8a\xe5\x85\xb6\xe5\x9c\xa8\xe8\xb3\x87\xe6\x96\x99\xe7\xa7\x91\xe5\xad\xb8\xe5\x92\x8c\xe6\x99\xba\xe6\x85\xa7\xe7\xb3\xbb\xe7\xb5\xb1\xe9\x96\x8b\xe7\x99\xbc\xe4\xb8\xad\xe7\x9a\x84\xe6\x87\x89\xe7\x94\xa8\xe3\x80\x82\n\xe5\x85\xb7\xe9\xab\x94\xe7\x9b\xae\xe6\xa8\x99\n\xe5\xae\x8c\xe6\x88\x90\xe6\x9c\xac\xe8\xaa\xb2\xe7\xa8\x8b\xe5\xbe\x8c\xef\xbc\x8c\xe5\xad\xb8\xe7\x94\x9f\xe5\xb0\x87\xe8\x83\xbd\xe5\xa4\xa0\xef\xbc\x9a\n\xe8\xaa\x8d\xe8\xad\x98\xe5\x88\xb0\xe7\xae\xa1\xe7\x90\x86\xe6\xb5\xb7\xe9\x87\x8f\xe8\xb3\x87\xe8\xa8\x8a\xe7\x9a\x84\xe5\x95\x8f\xe9\xa1\x8c\xef\xbc\x8c\xe4\xbb\xa5\xe5\x8f\x8a\xe5\xb0\x8d\xe9\xab\x98\xe6\x95\x88\xe8\xb3\x87\xe6\x96\x99\xe7\xb5\x90\xe6\xa7\x8b\xe5\x92\x8c\xe6\xbc\x94\xe7\xae\x97\xe6\xb3\x95\xe9\x80\xb2\xe8\xa1\x8c\xe8\x99\x95\xe7\x90\x86\xe5\x92\x8c\xe5\x88\x86\xe6\x9e\x90\xe7\x9a\x84\xe9\x9c\x80\xe6\xb1\x82\xe3\x80\x82\n\xe5\xad\xb8\xe7\xbf\x92\xe3\x80\x81\xe5\xaf\xa6\xe7\x8f\xbe\xe4\xb8\xa6\xe6\xaf\x94\xe8\xbc\x83\xe8\x88\x87\xe8\xb3\x87\xe8\xa8\x8a\xe6\x90\x9c\xe5\xb0\x8b\xe5\x92\x8c\xe6\xaa\xa2\xe7\xb4\xa2\xe7\x9b\xb8\xe9\x97\x9c\xe7\x9a\x84\xe4\xb8\x8d\xe5\x90\x8c\xe8\xb3\x87\xe6\x96\x99\xe7\xb5\x90\xe6\xa7\x8b\xe7\x9a\x84\xe6\x95\x88\xe8\x83\xbd\xe3\x80\x82\n\xe7\x90\x86\xe8\xa7\xa3\xe6\x89\x80\xe7\xa0\x94\xe7\xa9\xb6\xe7\x9a\x84\xe8\xb3\x87\xe6\x96\x99\xe7\xb5\x90\xe6\xa7\x8b\xe5\x92\x8c\xe6\xbc\x94\xe7\xae\x97\xe6\xb3\x95\xe5\xa6\x82\xe4\xbd\x95\xe6\x88\x90\xe7\x82\xba\xe8\xb3\x87\xe6\x96\x99\xe7\xa7\x91\xe5\xad\xb8\xe6\x87\x89\xe7\x94\xa8\xef\xbc\x88\xe4\xbe\x8b\xe5\xa6\x82\xe6\x90\x9c\xe5\xb0\x8b\xe5\xbc\x95\xe6\x93\x8e\xe3\x80\x81\xe6\x8e\xa8\xe8\x96\xa6\xe7\xb3\xbb\xe7\xb5\xb1\xe5\x92\x8c\xe7\xa4\xbe\xe4\xba\xa4\xe7\xb6\xb2\xe8\xb7\xaf\xe5\x88\x86\xe6\x9e\x90\xef\xbc\x89\xe9\x96\x8b\xe7\x99\xbc\xe7\x9a\x84\xe5\x9f\xba\xe7\xa4\x8e\xe3\x80\x82\n\xe9\x81\xb8\xe6\x93\x87\xe4\xb8\xa6\xe8\xaa\xbf\xe6\x95\xb4\xe5\x90\x88\xe9\x81\xa9\xe7\x9a\x84\xe8\xb3\x87\xe6\x96\x99\xe7\xb5\x90\xe6\xa7\x8b\xe5\x92\x8c\xe6\xbc\x94\xe7\xae\x97\xe6\xb3\x95\xe4\xbe\x86\xe8\xa7\xa3\xe6\xb1\xba\xe8\x88\x87\xe6\xb5\xb7\xe9\x87\x8f\xe8\xb3\x87\xe6\x96\x99\xe7\xae\xa1\xe7\x90\x86\xe5\x92\x8c\xe5\x88\x86\xe6\x9e\x90\xe7\x9b\xb8\xe9\x97\x9c\xe7\x9a\x84\xe5\x85\xb7\xe9\xab\x94\xe5\x95\x8f\xe9\xa1\x8c\xe3\x80\x82\n\xe6\xb7\xb1\xe5\x85\xa5\xe4\xba\x86\xe8\xa7\xa3\xe8\xb3\x87\xe6\x96\x99\xe7\xb5\x84\xe7\xb9\x94\xe5\x92\x8c\xe8\xb3\x87\xe8\xa8\x8a\xe8\xa8\x98\xe9\x8c\x84\xe7\x9a\x84\xe6\xa6\x82\xe5\xbf\xb5\xef\xbc\x8c\xe5\x88\x86\xe6\x9e\x90\xe5\x90\x84\xe7\xa8\xae\xe8\xa1\xa8\xe7\xa4\xba\xe5\x92\x8c\xe5\x84\xb2\xe5\xad\x98\xe5\xbd\xa2\xe5\xbc\x8f\xe3\x80\x82\n'

3.3Escritura de archivos

De forma similar a la lectura, podemos escribir en un archivo utilizando el modo de apertura "w" (write) o "a" (append). El modo "w" sobrescribe el archivo si ya existe, mientras que "a" agrega contenido al final del archivo.

Escribir todo el contenido de una vez

archivo = "texto.txt"

try:
    f = open(archivo, "w", encoding="utf-8")
except Exception as e:
    print(f"Error inesperado: {e}")
else:
    try:
        f.write("Nuevo contenido para el archivo\n")
    except Exception as e:
        print(f"Error inesperado: {e}")
    else:
        print("Contenido escrito correctamente")
    finally:
        f.close()
Output
Contenido escrito correctamente

Escribir línea por línea

archivo = "texto.txt"

try:
    f = open(archivo, "w", encoding="utf-8")
except Exception as e:
    print(f"Error inesperado: {e}")
else:
    try:
        lista = []
        for i in range(5):
            lista.append(f"Línea {i}\n")
        f.writelines(lista)
    except Exception as e:
        print(f"Error inesperado: {e}")
    else:
        print("Contenido escrito correctamente")
    finally:
        f.close()
Output
Contenido escrito correctamente

archivo = "texto.txt"

try:
    f = open(archivo, "a", encoding="utf-8")
except Exception as e:
    print(f"Error inesperado: {e}")
else:
    try:
        lista = []
        for i in range(5):
            lista.append(f"Línea {i}\n")
        f.writelines(lista)
        f.write("學科基礎\n")
    except Exception as e:
        print(f"Error inesperado: {e}")
    else:
        print("Contenido agregado correctamente")
    finally:
        f.close()
Output
Contenido agregado correctamente

3.4Entorno seguro para manipular archivos

Python provee un entorno seguro para manipular archivos con la sentencia with que nos asegura que siempre se cierra el archivo cuando se sale del bloque.

def copiar_archivo(origen, destino):
    with open(origen, "r") as f_origen, open(destino, "w") as f_destino:
        while bloque := f_origen.read(1024):
            f_destino.write(bloque)


def mostrar_archivo(archivo):
    with open(archivo, "r") as f:
        for linea in f:
            print(linea)


# Copiamos texto.txt a copia.txt
copiar_archivo("texto.txt", "copia.txt")
mostrar_archivo("copia.txt")
Output
Línea 0

Línea 1

Línea 2

Línea 3

Línea 4

Línea 0

Línea 1

Línea 2

Línea 3

Línea 4

學科基礎

El siguiente script nos permite comparar byte a byte dos archivos para ver si son iguales

def comparar_archivos(archivo1, archivo2):
    with open(archivo1, "rb") as f1, open(archivo2, "rb") as f2:
        while True:
            bloque1 = f1.read(1024)
            bloque2 = f2.read(1024)
            if bloque1 != bloque2:
                print("Los archivos son diferentes")
                return
            if not bloque1:
                break
    print("Los archivos son iguales")


# Comparamos texto.txt con copia.txt
comparar_archivos("texto.txt", "copia.txt")
Output
Los archivos son iguales

4Recursos para profundizar

Taller de Python
Introspección y reflexión
Taller de Python
Persistencia de datos