{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Leer y escribir archivos\n",
    "\n",
    "Abrir lo que te mandan sin romperlo, y por qué a veces ves \"á\" donde debería haber una á.\n",
    "\n",
    "Cuaderno de soluciones del capítulo 10 de **Python desde cero**, de Miss Yera.\n",
    "\n",
    "Corre de arriba abajo. Si lo abres en Google Colab no necesitas instalar nada.\n",
    "\n",
    "Capítulo completo: https://missyera.com/guias/python-desde-cero/archivos/\n",
    "\n",
    "Este es el cuaderno de **soluciones**. Trae el código de cada ejercicio, la\n",
    "explicación de la trampa y la respuesta del quiz. Si vienes del cuaderno de\n",
    "práctica sin haberlo intentado, vuelve 🙂"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Antes de empezar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import urllib.request\n",
    "\n",
    "# Este capitulo abre el archivo por su nombre, sin URL, que es lo que se hace\n",
    "# cuando lo tienes al lado. Aqui se baja primero para que exista.\n",
    "for nombre in ['ventas-miss-yera.csv']:\n",
    "    urllib.request.urlretrieve(f\"https://missyera.com/static/datasets/{nombre}\", nombre)\n",
    "    print(nombre, \"lista\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hola! Vamos por lo que te mandan de verdad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hasta ahora los datos los escribíamos nosotras dentro del código. En el\n",
    "trabajo real te llegan en un archivo, casi siempre por correo, casi siempre con\n",
    "algún problema 😅\n",
    "\n",
    "Este capítulo va de abrirlos sin romperlos. Y de la codificación, que es el\n",
    "dolor número uno de trabajar con datos en español y que casi nadie explica\n",
    "bien.\n",
    "\n",
    "Y dime si te suena esto: **¿abriste alguna vez un archivo y viste á donde tenía que ir una á?** Eso tiene nombre, tiene causa y tiene arreglo, y los tres están en este capítulo 🔤"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## with open, y por qué siempre con with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tempfile\n",
    "from pathlib import Path\n",
    "\n",
    "# Uso una carpeta temporal para no ensuciar la tuya\n",
    "carpeta = Path(tempfile.mkdtemp())\n",
    "archivo = carpeta / 'notas.txt'\n",
    "\n",
    "with open(archivo, 'w', encoding='utf-8') as f:\n",
    "    f.write('Primera línea\\n')\n",
    "    f.write('Segunda línea con tildes: áéíóú ñ\\n')\n",
    "\n",
    "with open(archivo, encoding='utf-8') as f:\n",
    "    contenido = f.read()\n",
    "\n",
    "print(contenido)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tres cosas de ahí que valen para siempre:\n",
    "\n",
    "- 🔒 **`with`** cierra el archivo solo, aunque el\n",
    "código de dentro reviente. Sin él tienes que acordarte de cerrarlo, y no te vas\n",
    "a acordar.\n",
    "\n",
    "- ✍️ El modo: `'r'` leer (es el que viene por defecto),\n",
    "`'w'` escribir **borrando lo que había**,\n",
    "`'a'` agregar al final.\n",
    "\n",
    "- 🌍 **`encoding='utf-8'` siempre**, al leer y al\n",
    "escribir. En un minuto te explico por qué.\n",
    "\n",
    "Ese `'w'` borra sin preguntar, así que ten cuidadito. Si querías\n",
    "agregar y pusiste `'w'`, te quedaste sin lo anterior 😬\n",
    "\n",
    "Para leer línea por línea, que es lo que haces con archivos grandes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(archivo, encoding='utf-8') as f:\n",
    "    for numero, linea in enumerate(f, start=1):\n",
    "        print(numero, repr(linea))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fíjate en el `\\n` al final de cada línea: viene incluido. Por eso\n",
    "casi siempre se hace `linea.strip()` antes de usarla.\n",
    "\n",
    "Y esta forma de leer tiene una ventaja enorme: **no carga el archivo\n",
    "entero en memoria**. Con un archivo de dos gigas, `f.read()` te\n",
    "tumba la máquina y el bucle no."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La codificación, o por qué ves \"á\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta es la parte más importante del capítulo. Presta atención dos minutos y te\n",
    "ahorras años de misterio 💜\n",
    "\n",
    "Un archivo de texto no guarda letras, guarda números. La\n",
    "**codificación** es la tabla que dice qué número es cada letra.\n",
    "\n",
    "Hay dos que te vas a encontrar:\n",
    "\n",
    "- 🌍 **UTF-8.** El estándar de hoy. Le entran todos los idiomas.\n",
    "Es lo que usa Python por defecto y lo que debes usar siempre que puedas.\n",
    "\n",
    "- 🗄️ **latin-1** (también llamado ISO-8859-1 o cp1252). El de\n",
    "Windows en español, de toda la vida. Sigue saliendo de sistemas antiguos y de\n",
    "algunos Excel.\n",
    "\n",
    "Y ahora mira lo que pasa cuando se confunden, que es exactamente lo que has\n",
    "visto mil veces sin saber por qué:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Esto revienta a propósito.** Se ejecuta dentro de un `try` para que puedas seguir con \"ejecutar todo\" y aun así ver la queja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    texto = 'Cañete, Trujillo, Ancón'\n",
    "\n",
    "    # Alguien lo guardo con latin-1\n",
    "    bytes_latin = texto.encode('latin-1')\n",
    "\n",
    "    # Y tu lo lees como si fuera utf-8\n",
    "    print(bytes_latin.decode('utf-8'))\n",
    "except Exception as e:\n",
    "    print(f'{type(e).__name__}: {e}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y la queja que tiene que salir es esta:\n",
    "\n",
    "```\n",
    "UnicodeDecodeError: 'utf-8' codec can't decode byte 0xf1 in position 2: invalid continuation byte\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese es el error que revienta. Pero hay un caso peor, el que **no**\n",
    "revienta:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Guardado en utf-8 y leido como latin-1: no falla, sale mal\n",
    "bytes_utf = texto.encode('utf-8')\n",
    "print(bytes_utf.decode('latin-1'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahí está 😱 Eso tiene nombre y se llama **mojibake**. El archivo\n",
    "se lee sin un solo error y las tildes salen convertidas en pares de símbolos\n",
    "raros.\n",
    "\n",
    "La regla para reconocerlo: **si ves \"Ã\" seguida de otro símbolo, es\n",
    "UTF-8 leído como latin-1**. Y se arregla leyendo con la codificación\n",
    "correcta, no reemplazando caracteres a mano.\n",
    "\n",
    "Cuando no sepas cuál es, este orden funciona casi siempre:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "datos = texto.encode('latin-1')\n",
    "\n",
    "for codificacion in ['utf-8', 'latin-1']:\n",
    "    try:\n",
    "        print(codificacion, '->', datos.decode(codificacion))\n",
    "        break\n",
    "    except UnicodeDecodeError:\n",
    "        print(codificacion, '-> no')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primero UTF-8, y si revienta, latin-1. En ese orden, porque latin-1 casi nunca\n",
    "falla (acepta cualquier byte) y por eso probarlo primero te esconde el\n",
    "problema."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CSV sin pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sí, pandas lo hace más fácil, y aun así vale la pena conocer el módulo\n",
    "`csv`: es de la librería estándar, no carga el archivo entero en\n",
    "memoria y no se confunde con las comas dentro de un campo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "ruta = carpeta / 'ventas.csv'\n",
    "filas = [\n",
    "    ['cliente', 'ciudad', 'monto'],\n",
    "    ['C0045', 'Trujillo', '480.37'],\n",
    "    ['C0325', 'Lima, Miraflores', '524.90'],\n",
    "]\n",
    "\n",
    "with open(ruta, 'w', newline='', encoding='utf-8') as f:\n",
    "    csv.writer(f).writerows(filas)\n",
    "\n",
    "print(ruta.read_text(encoding='utf-8'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mira la última línea: como la ciudad tenía una coma dentro, el módulo la puso\n",
    "entre comillas sola. Si hubieras armado el CSV pegando textos con\n",
    "`','.join()`, esa fila habría quedado con cuatro campos en vez de\n",
    "tres y nadie te habría avisado 🙃\n",
    "\n",
    "Ese `newline=''` parece un detalle raro y hace falta: sin él, en\n",
    "Windows te salen líneas en blanco entre fila y fila.\n",
    "\n",
    "Para leer, lo mejor es `DictReader`, que te da cada fila como\n",
    "diccionario usando la cabecera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(ruta, encoding='utf-8') as f:\n",
    "    for fila in csv.DictReader(f):\n",
    "        print(fila['ciudad'], '->', float(fila['monto']) * 1.18)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pides por nombre de columna y no por posición, así que si mañana cambian el\n",
    "orden de las columnas tu código sigue funcionando 🌸"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para leer Excel hace falta instalar `openpyxl`\n",
    "(`pip install openpyxl`). Después es directo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from openpyxl import Workbook, load_workbook\n",
    "\n",
    "libro = Workbook()\n",
    "hoja = libro.active\n",
    "hoja.title = 'Ventas'\n",
    "\n",
    "hoja.append(['cliente', 'ciudad', 'monto'])\n",
    "hoja.append(['C0045', 'Trujillo', 480.37])\n",
    "hoja.append(['C0325', 'Lima', 524.90])\n",
    "\n",
    "ruta_xlsx = carpeta / 'ventas.xlsx'\n",
    "libro.save(ruta_xlsx)\n",
    "\n",
    "leido = load_workbook(ruta_xlsx)\n",
    "print(leido.sheetnames)\n",
    "\n",
    "for fila in leido['Ventas'].iter_rows(min_row=2, values_only=True):\n",
    "    print(fila)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese `min_row=2` se salta la cabecera y `values_only=True`\n",
    "te da los valores en vez de los objetos de celda, que es lo que quieres el 99%\n",
    "de las veces.\n",
    "\n",
    "Dos avisos sobre Excel, aprendidos a la mala:\n",
    "\n",
    "- 🧮 **Las fórmulas no vienen calculadas.** Por defecto lees la\n",
    "fórmula (`=A2*1.18`) y no su resultado. Con\n",
    "`load_workbook(ruta, data_only=True)` lees el último valor calculado,\n",
    "que existe solo si el archivo se abrió en Excel alguna vez.\n",
    "\n",
    "- 📅 **Las fechas vienen como fechas** si la celda tenía formato\n",
    "de fecha, y como texto si no. Siempre revisa el tipo antes de confiar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JSON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "ventas = [\n",
    "    {'cliente': 'C0045', 'ciudad': 'Trujillo', 'monto': 480.37},\n",
    "    {'cliente': 'C0325', 'ciudad': 'Ñaña', 'monto': 524.90},\n",
    "]\n",
    "\n",
    "ruta_json = carpeta / 'ventas.json'\n",
    "with open(ruta_json, 'w', encoding='utf-8') as f:\n",
    "    json.dump(ventas, f, ensure_ascii=False, indent=2)\n",
    "\n",
    "print(ruta_json.read_text(encoding='utf-8'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese `ensure_ascii=False` es el que hace que la ñ se escriba como ñ.\n",
    "Sin él sale `\"\\u00d1a\\u00f1a\"`, que es válido y es ilegible.\n",
    "\n",
    "Y las cuatro funciones de `json`, que se confunden siempre:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Función | Qué hace |\n",
    "|---|---|\n",
    "| `json.load(f)` | De archivo a Python |\n",
    "| `json.loads(texto)` | De texto a Python |\n",
    "| `json.dump(obj, f)` | De Python a archivo |\n",
    "| `json.dumps(obj)` | De Python a texto |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La `s` del final es de \"string\". Con eso ya no las confundes 😄"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Leer el archivo del libro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos a leer el CSV de verdad con el que vamos a trabajar el resto del libro,\n",
    "todavía sin pandas:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "from urllib.request import urlopen\n",
    "\n",
    "URL = 'https://missyera.com/static/datasets/ventas-miss-yera.csv'\n",
    "\n",
    "with urlopen(URL) as respuesta:\n",
    "    texto = respuesta.read().decode('utf-8')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y si ya lo descargaste, que es lo que vas a hacer casi siempre, se lee igual\n",
    "pero con `open` y la ruta de tu computadora:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "ARCHIVO = 'ventas-miss-yera.csv'      # descargado al lado del cuaderno\n",
    "\n",
    "with open(ARCHIVO, encoding='utf-8') as f:\n",
    "    texto = f.read()\n",
    "\n",
    "lineas = texto.splitlines()\n",
    "print('filas (con cabecera):', len(lineas))\n",
    "print(lineas[0])\n",
    "\n",
    "lector = csv.DictReader(lineas)\n",
    "primera = next(lector)\n",
    "print(primera['ciudad'], primera['monto'], primera['compro'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tres mil treinta y ocho líneas contando la cabecera, o sea 3.037 ventas. Y\n",
    "fíjate en algo: `primera['monto']` devolvió `'480.37'`\n",
    "**como texto**, porque un CSV no guarda tipos. Todo lo que sale de\n",
    "ahí es texto hasta que tú lo conviertas.\n",
    "\n",
    "Eso es exactamente lo que pandas te va a hacer solo en el capítulo 12, y ahora\n",
    "ya sabes que no es magia 🌟"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Escribir, que es la otra mitad del trabajo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todo el capítulo ha ido de leer. Pero un análisis que no sale a ningún sitio\n",
    "no le sirve a nadie, y casi siempre sale a un CSV que alguien va a abrir en\n",
    "Excel 📤"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "import os\n",
    "import tempfile\n",
    "\n",
    "carpeta = tempfile.mkdtemp()\n",
    "ruta = os.path.join(carpeta, 'resumen.csv')\n",
    "\n",
    "filas = [{'segmento': 'Bodega', 'ventas': 707, 'total': 126340.5},\n",
    "         {'segmento': 'Mayorista', 'ventas': 750, 'total': 1392252.75}]\n",
    "\n",
    "with open(ruta, 'w', newline='', encoding='utf-8') as f:\n",
    "    escritor = csv.DictWriter(f, fieldnames=['segmento', 'ventas', 'total'])\n",
    "    escritor.writeheader()\n",
    "    escritor.writerows(filas)\n",
    "\n",
    "print(open(ruta, encoding='utf-8').read().rstrip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tres cosas de ese bloque que no son opcionales 🔧\n",
    "\n",
    "**El `newline=''`** es el que más gente pilla. El\n",
    "módulo `csv` ya escribe su propio salto de línea, así que si no le\n",
    "dices esto, en Windows te salen filas vacías entre medio. En Linux y Mac no se\n",
    "nota, y por eso el archivo llega roto justo cuando lo abre otra persona.\n",
    "\n",
    "**El `'w'`** borra el archivo entero antes de\n",
    "escribir. Si querías añadir al final, es `'a'`.\n",
    "\n",
    "**Y el `encoding='utf-8'`**, que es el mismo cuidado\n",
    "de la sección de arriba pero en la otra dirección. Un archivo escrito sin\n",
    "declarar codificación es el mojibake de otra persona 🔤\n",
    "\n",
    "Para Excel hay un detalle más: Excel espera `utf-8-sig`, que es\n",
    "UTF-8 con una marca invisible al principio. Con `utf-8` a secas, los\n",
    "acentos se ven mal al abrirlo con doble clic 🪟"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Archivos que no caben en memoria"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un CSV de dos giga no se abre con `pd.read_csv` en un portátil\n",
    "normal. Pero casi nunca hace falta tenerlo entero: hace falta recorrerlo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grande = os.path.join(carpeta, 'grande.csv')\n",
    "with open(grande, 'w', encoding='utf-8') as f:\n",
    "    f.write('monto\\\\n')\n",
    "    for i in range(100000):\n",
    "        f.write(f'{i % 500}\\\\n')\n",
    "\n",
    "total = 0\n",
    "lineas = 0\n",
    "with open(grande, encoding='utf-8') as f:\n",
    "    next(f)                       # saltarse la cabecera\n",
    "    for linea in f:\n",
    "        total += int(linea)\n",
    "        lineas += 1\n",
    "\n",
    "print(f'{lineas} lineas sumadas, total {total}')\n",
    "print('el archivo pesa', os.path.getsize(grande), 'bytes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese `for linea in f` es la clave y es una de las cosas más bonitas\n",
    "de Python: **no carga el archivo**. Va leyendo una línea, te la da,\n",
    "la suelta y pasa a la siguiente 🚿\n",
    "\n",
    "Por eso funciona igual con cien mil líneas que con cien millones. Lo que\n",
    "gasta memoria es `f.read()` o `f.readlines()`, que sí se\n",
    "lo traen todo.\n",
    "\n",
    "La versión de pandas de esta misma idea es\n",
    "`pd.read_csv(ruta, chunksize=100000)`, que te va entregando trozos\n",
    "del tamaño que le pidas. Misma idea, más cómoda 🐼"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Escribir y volver a leer\n",
    "\n",
    "Escribe tres líneas en un archivo y vuelve a leerlas\n",
    "contando cuántas son."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tempfile\n",
    "from pathlib import Path\n",
    "\n",
    "ruta = Path(tempfile.mkdtemp()) / 'prueba.txt'\n",
    "\n",
    "with open(ruta, 'w', encoding='utf-8') as f:\n",
    "    for ciudad in ['Lima', 'Cusco', 'Piura']:\n",
    "        f.write(ciudad + '\\n')\n",
    "\n",
    "with open(ruta, encoding='utf-8') as f:\n",
    "    lineas = [l.strip() for l in f]\n",
    "\n",
    "print(lineas, len(lineas))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "['Lima', 'Cusco', 'Piura'] 3\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. El modo que borra\n",
    "\n",
    "Escribe con `'w'` dos veces y comprueba que la\n",
    "segunda borró la primera. Después hazlo con `'a'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ruta2 = Path(tempfile.mkdtemp()) / 'cierre-de-caja.txt'\n",
    "\n",
    "with open(ruta2, 'w', encoding='utf-8') as f:\n",
    "    f.write('caja del lunes\\n')\n",
    "with open(ruta2, 'w', encoding='utf-8') as f:\n",
    "    f.write('caja del martes\\n')\n",
    "print(repr(ruta2.read_text(encoding='utf-8')))\n",
    "\n",
    "with open(ruta2, 'a', encoding='utf-8') as f:\n",
    "    f.write('caja del miércoles\\n')\n",
    "print(repr(ruta2.read_text(encoding='utf-8')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "'caja del martes\\n'\n",
    "'caja del martes\\ncaja del miércoles\\n'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Reproduce el mojibake\n",
    "\n",
    "Toma el texto \"Cañete y José\" y muéstralo mal leído a\n",
    "propósito."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = 'Cañete y José'\n",
    "print(t.encode('utf-8').decode('latin-1'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Cañete y José\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cada letra con tilde se convirtió en dos símbolos. Cuando lo veas en un\n",
    "archivo, ya sabes qué pasó y no hace falta reemplazar nada a mano."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Detectar la codificación\n",
    "\n",
    "Escribe una función que pruebe UTF-8 y después latin-1, y\n",
    "devuelva cuál funcionó."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decodifica(datos):\n",
    "    for cod in ['utf-8', 'latin-1']:\n",
    "        try:\n",
    "            return cod, datos.decode(cod)\n",
    "        except UnicodeDecodeError:\n",
    "            continue\n",
    "    return None, None\n",
    "\n",
    "print(decodifica('Cañete'.encode('utf-8')))\n",
    "print(decodifica('Cañete'.encode('latin-1')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "('utf-8', 'Cañete')\n",
    "('latin-1', 'Cañete')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las dos salieron bien porque el orden es el correcto. Al revés, la primera\n",
    "habría dado mojibake sin quejarse."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. La coma dentro del campo\n",
    "\n",
    "Escribe un CSV donde un campo tenga una coma y comprueba que\n",
    "al leerlo siguen siendo tres columnas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "ruta3 = Path(tempfile.mkdtemp()) / 'comas.csv'\n",
    "with open(ruta3, 'w', newline='', encoding='utf-8') as f:\n",
    "    w = csv.writer(f)\n",
    "    w.writerow(['id', 'direccion', 'monto'])\n",
    "    w.writerow(['1', 'Av. Larco 123, Miraflores', '480.37'])\n",
    "\n",
    "with open(ruta3, encoding='utf-8') as f:\n",
    "    for fila in csv.reader(f):\n",
    "        print(len(fila), fila)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "3 ['id', 'direccion', 'monto']\n",
    "3 ['1', 'Av. Larco 123, Miraflores', '480.37']\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. DictReader y un total\n",
    "\n",
    "Con el CSV anterior, suma los montos convirtiéndolos a\n",
    "número."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(ruta3, encoding='utf-8') as f:\n",
    "    total = sum(float(fila['monto']) for fila in csv.DictReader(f))\n",
    "\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "480.37\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese `float()` no es opcional: sin él estarías concatenando textos y\n",
    "el \"total\" saldría absurdo, como en el capítulo 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. JSON con tildes\n",
    "\n",
    "Guarda un diccionario con eñes en JSON, primero sin\n",
    "`ensure_ascii=False` y después con él."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "d = {'ciudad': 'Ñaña'}\n",
    "print(json.dumps(d))\n",
    "print(json.dumps(d, ensure_ascii=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "{\"ciudad\": \"\\u00d1a\\u00f1a\"}\n",
    "{\"ciudad\": \"Ñaña\"}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los dos son JSON válido y cualquier programa lee los dos. El segundo lo lee\n",
    "además un ser humano 💜"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. Contar filas sin cargar el archivo\n",
    "\n",
    "Cuenta las líneas de un archivo recorriéndolo, sin usar\n",
    "`read()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ruta4 = Path(tempfile.mkdtemp()) / 'ventas-del-anio.txt'\n",
    "with open(ruta4, 'w', encoding='utf-8') as f:\n",
    "    for i in range(1000):\n",
    "        f.write(f'venta {i}\\n')\n",
    "\n",
    "with open(ruta4, encoding='utf-8') as f:\n",
    "    print(sum(1 for _ in f))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "1000\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese `sum(1 for _ in f)` cuenta sin guardar nada en memoria. Con mil\n",
    "líneas da igual; con veinte millones es la diferencia entre que funcione y que\n",
    "no."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. Guardar el resultado con la fecha en el nombre\n",
    "\n",
    "Un informe que se sobreescribe cada vez es un informe que\n",
    "alguien va a perder. Ponle la fecha al archivo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "\n",
    "def guarda_resumen(filas, carpeta, dia=None):\n",
    "    dia = dia or date.today()\n",
    "    ruta = os.path.join(carpeta, f'resumen-{dia:%Y-%m-%d}.csv')\n",
    "    with open(ruta, 'w', newline='', encoding='utf-8-sig') as f:\n",
    "        escritor = csv.DictWriter(f, fieldnames=list(filas[0]))\n",
    "        escritor.writeheader()\n",
    "        escritor.writerows(filas)\n",
    "    return ruta\n",
    "\n",
    "ruta = guarda_resumen(filas, carpeta, dia=date(2026, 9, 15))\n",
    "print('escrito en', os.path.basename(ruta))\n",
    "print('pesa', os.path.getsize(ruta), 'bytes')\n",
    "print()\n",
    "print(open(ruta, encoding='utf-8-sig').read().rstrip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "escrito en resumen-2026-09-15.csv\n",
    "pesa 73 bytes\n",
    "\n",
    "segmento,ventas,total\n",
    "Bodega,707,126340.5\n",
    "Mayorista,750,1392252.75\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El `{dia:%Y-%m-%d}` pone la fecha al derecho, empezando por el\n",
    "año. Eso no es estética: es lo que hace que los archivos se **ordenen\n",
    "solos** por nombre 📅\n",
    "\n",
    "Con `15-09-2026` el ordenador te pone septiembre de 2026 al lado\n",
    "de septiembre de 2019, y a la tercera vez que te pasa entiendes por qué todo el\n",
    "mundo usa el otro orden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. Contar sin cargar, y encontrar la fila rota\n",
    "\n",
    "Recorre un archivo con una fila mal formada y localízala\n",
    "sin que el programa se caiga."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sucio = os.path.join(carpeta, 'sucio.csv')\n",
    "open(sucio, 'w', encoding='utf-8').write(\n",
    "    'cliente,monto\\\\n'\n",
    "    'Rosita,340\\\\n'\n",
    "    'Sol,ochenta\\\\n'\n",
    "    'Luz,120\\\\n'\n",
    "    'Mar,\\\\n')\n",
    "\n",
    "total = 0\n",
    "buenas = 0\n",
    "problemas = []\n",
    "with open(sucio, encoding='utf-8') as f:\n",
    "    for numero, fila in enumerate(csv.DictReader(f), start=2):\n",
    "        try:\n",
    "            total += float(fila['monto'])\n",
    "            buenas += 1\n",
    "        except ValueError:\n",
    "            problemas.append((numero, fila['cliente'], repr(fila['monto'])))\n",
    "\n",
    "print(f'sumadas {buenas} filas, total {total}')\n",
    "for numero, cliente, valor in problemas:\n",
    "    print(f'  linea {numero}: {cliente} tiene monto {valor}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "sumadas 0 filas, total 0\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese `start=2` es el detalle que convierte esto en útil: la fila 1\n",
    "es la cabecera, así que el número que imprimes es **el que va a ver quien\n",
    "abra el archivo** 🔢\n",
    "\n",
    "Y fíjate en el patrón entero, que es el que uso siempre con archivos de\n",
    "otros: no me paro en el primer problema, los recojo todos y al final entrego la\n",
    "lista. Una sola vuelta y una sola conversación, en vez de arreglar de uno en uno\n",
    "🧾"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La columna fantasma que aparece sola"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una que no rompe nada y que vas a reconocer al instante en cuanto la veas una vez, porque está en la mitad de los CSV que circulan por las empresas 👻"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La trampa\n",
    "\n",
    "Guardas el archivo limpio para mandárselo al equipo. Lo abres para comprobar y se ve bien.\n",
    "\n",
    "```\n",
    "datos.to_csv('ventas_limpias.csv')\n",
    "\n",
    "# y al releerlo al dia siguiente:\n",
    "d = pd.read_csv('ventas_limpias.csv')\n",
    "print(d.columns.tolist())\n",
    "# ['Unnamed: 0', 'id_cliente', 'ciudad']\n",
    "```\n",
    "\n",
    "**Qué está mal**\n",
    "\n",
    "Se coló una columna 👻 `to_csv` escribe el índice por defecto, y al releer el archivo ese índice ya no es un índice: es una columna más, sin nombre.\n",
    "\n",
    "Y crece. Cada vez que alguien lee, toca y vuelve a guardar, aparece otra `Unnamed`. He visto archivos con cuatro, y cada una es una ronda de \"lo abrí, lo arreglé y lo devolví\".\n",
    "\n",
    "Se escribe con `index=False` salvo que el índice signifique algo de verdad, como una fecha. Y si al leer te encuentras una `Unnamed: 0`, ya sabes que ese archivo pasó por las manos de alguien que no lo puso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comprueba que lo tienes\n",
    "\n",
    "Abres un CSV con acentos y salen símbolos raros. ¿Qué falta?\n",
    "\n",
    "a) Decirle con qué codificación está escrito el archivo\n",
    "\n",
    "b) Abrirlo en modo binario\n",
    "\n",
    "c) Quitarle los acentos al archivo\n",
    "\n",
    "d) Usar pandas en vez de open\n",
    "\n",
    "---\n",
    "\n",
    "**La correcta es la a.**\n",
    "\n",
    "*b)* Eso te devuelve bytes y el problema sigue, solo que más crudo.\n",
    "\n",
    "*c)* Eso arregla este archivo y ninguno de los siguientes.\n",
    "\n",
    "*d)* pandas tiene el mismo problema y el mismo parámetro.\n",
    "\n",
    "Un archivo de texto no dice cómo está codificado: hay que saberlo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lo que te llevas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 🔒 `with open(...)` siempre, que cierra solo.\n",
    "\n",
    "- 🌍 `encoding='utf-8'` al leer y al escribir, siempre.\n",
    "\n",
    "- 👀 Si ves \"Ã\" seguida de un símbolo, es UTF-8 leído como latin-1.\n",
    "\n",
    "- 📄 Prueba UTF-8 primero y latin-1 después, en ese orden.\n",
    "\n",
    "- 🧾 Para CSV usa el módulo `csv`, que resuelve solo las comas\n",
    "dentro de un campo.\n",
    "\n",
    "- 🔤 Todo lo que sale de un CSV es texto hasta que tú lo conviertas.\n",
    "\n",
    "Y si de todo el capítulo te llevas una sola frase, que sea esta:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un archivo sin codificación declarada funciona hasta que cambia de\n",
    "computadora."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y cuando ese archivo limpio ya no es para ti sino para que alguien lo\n",
    "mire, el siguiente paso suele ser un tablero. La\n",
    "[guía de Power BI](https://missyera.com/guias/power-bi-desde-cero/) arranca justo\n",
    "ahí, conectando el CSV que acabas de dejar decente 📈\n",
    "\n",
    "En el capítulo 11 entra NumPy, y con él la razón por la que un cálculo sobre\n",
    "un millón de números puede tardar un segundo o tardar dos minutos.\n",
    "\n",
    "Que tengas un hermoso día! 🌟"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Ese era el capítulo 10 de **Python desde cero**. El texto completo, con las salidas de cada bloque, está en https://missyera.com/guias/python-desde-cero/archivos/\n",
    "\n",
    "Que tengas lindo día! 🌸"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}