Trabajando con archivos de texto en Python

Espero les sirva 😃

def read():
    names = []
    with open("./archivos/name.txt", "r", encoding="utf-8") as f:
        for line in f: 
            if len(line.strip()) > 0:
                names.append(line.strip())
    if len(names)> 0:
        print(names)
    else:
        print("Archivo vacio")

def write():
    names = []
    with open("./archivos/name.txt", "w" , encoding="utf-8") as f:
        for name in names:
            f.write(name)
            f.write('\n')

def agregar_nombre(nombre):
    with open("./archivos/name.txt", "a" , encoding="utf-8") as f:
        f.write(nombre)
        f.write("\n")

def borrar_nombre(nombre):
    names = []
    with open("./archivos/name.txt", "r", encoding="utf-8") as f:
        for line in f: 
            if len(line.strip()) > 0 and line.strip()!= nombre:
                names.append(line.strip())
    with open("./archivos/name.txt", "w" , encoding="utf-8") as f:
        for name in names:
            f.write(name)
            f.write('\n')

    
def run():
    sw = True
    while sw:
        try:
            print("""  
----------------------------------------------------------------------
            Seleccione un numero:
            1. Crear un nuevo archivo 
            2. Agregar nombre
            3. Listar nombre
            4. Borrar nombre
            5. Salir del programa
----------------------------------------------------------------------
            """)
            n = int(input("Ingrese una opcion :   "))
            if n == 1:
                write()
            elif n == 2:
                nombre = input("Ingrese el nombre a agregar: ")
                agregar_nombre(nombre)
            elif n == 3:
                read()
            elif n == 4:
                nombre = input("Ingrese el nombre a borrar : ")
                borrar_nombre(nombre)
            elif n ==5:
                sw = False
                print("Programa Terminado!")
        except ValueError :
                print("Error seleccione una opcion correcta")
    # write()

if __name__ == '__main__':
    run()

Compañeros si tienen un problema con la ruta del archivo, les recomiendo algo que me funcionó:

1. Ir al archivo ‘numbers.txt’ que aparece en el explorador de VSC
2. click derecho y click en --> ‘copiar ruta de acceso relativa’ y listo, con esa ruta inicias:
   por ejemplo la mía:

with open('./venv/archivos/numbers.txt, 'r', encoding = 'utf-8) as f:

encoding = "utf-8" Sirve para que Python pueda soportar caracteres del idioma español, como la “ñ” y letras con tilde.

Encuentro muy útil hacer una constante que defina la ruta absoluta del script para poder ejecutarlo desde cualquier lado (van a notar que si se ejecuta desde otro lado, la ruta “./archivos/numbers.txt” ya no sirve), esto sería, así:

import os
FILE_PATH=os.path.dirname(__file__)

def read():
    numbers = []
    with open(f"{FILE_PATH}/archivos/numbers.txt", "r", encoding="utf-8") as f:
        [numbers.append(int(line)) for line in f]
        
    print(numbers)

Si alguien tiene otra sugerencia, agradecería su comentario 😄

Un pequeño aporte, cuando estén trabajando con datos y tengan su .csv con los decimales en , y no .
en:
with open("./archivos/numeros.csv", “r”, encoding=“utf-8”, decimal=",") as f
con añadir decimal="," no tendrán que editar nada y pasan a procesar sus datos de inmediato.

Saludos a todos

En la funcion write() es buena práctica poner f.close() despues del ciclo for, para cerrar el archivo y no perder informacion.

Normalmente al archivo se le nombra con la letra " f " por convención.

Les dejo la manera de como hacerlo con list comprehensions:

numbers_txt = [int(line) for line in f] 
names_txt = [f.write(name + "\n") for name in names]  

Para que sea más elegante en la función de escritura, sólo hay que concatenar la constante de nueva línea:

for name in names:
f.write(name + ‘\n’)

✨ Es importante cerrar nuestro archivo, después de trabajar con el.

archivo.close()

Tuve un problema con la ubicación del archivo, VSC no la reconocía y la tomaba como FileNotFoundError, es decir, como si no existiera. Lo solucioné agregando

1. La ruta original y no la relativa
2. una r antes de la ruta, esto hace que convierta un string común a un raw string
   Espero a alguien le sirva

def read():
    numbers = []
    with open(r"C:\Users\alejandro\Documents\Visual Studio Code\Python\Manejo archivos\carpeta\numbers.txt" , "r") as f: 

Para los que no nos corrió el código en un inicio, acuérdense de sustituir el pass dentro de run() y colocar el nombre de la función que deseen imprimir en pantalla.

lo que se me ocurrio es pasar el objeto que se utilizo en la clase de filtrar datos a un archivo .json, luego leerlo y ejecutar las mismas consultas que hicimos, el codigo quedo asi:

import json

def es_par(num):
    return num%2 == 0

def run():
    with open("./data.json", "r") as f:
        DATA = json.load(f)
        all_python_devs = [worker['name'] for worker in DATA if worker['language'] == 'python']
        all_Platzi_workers = [worker['name'] for worker in DATA if worker['organization'] == 'Platzi']
        adults = list(filter(lambda worker: worker['age'] > 18, DATA))
        adults_name = list(map(lambda worker: worker['name'], adults))
        old_people = list(map(lambda worker: worker, DATA))

        print(all_python_devs)
        print(all_Platzi_workers)
        print(adults_name)
        print(old_people)

if __name__ == '__main__':
    run()

Hola, hice el ejercicio agrgandole una comprobacion al archivo de texto para que no salga ningun error en caso que contenga saltos de linea, espacios en blanco o algo que no sean numeros.
Lo hice agregando if line.isspace() or line.isalpha():
Los metodos isspace verifica que no sea un espacio o salto de linea y el metodo isalpha verifica si es texto, en cuyo caso se salta esa ejecucion en el cliclo for mediante la instruccion continue.

def read():
    numbers = []
    with open('./archivos/numbers.txt', 'r', encoding = 'utf-8') as f:
        for line in f:
            if line.isspace() or line.isalpha():
                continue
            numbers.append(int(line))
    print(numbers)


def write():
    names = ['Pepe', 'Marcela', 'Fredy', 'Juan', 'Ana', 'Mara']
    with open('./archivos/names.txt', 'a', encoding='utf-8') as f:
        for name in names:
            f.write(name)
            f.write('\n')

def run():
    read()
    write()


if __name__ == '__main__':
    run()

Una forma alternativa de escribir el archivo usando lo aprendido hasta ahora, con lambda functions y list comprehensions

with open("./files/names", "w", encoding="utf-8") as f:
list(map(lambda name: f.write(name+"\n") , [name for name in names]))

Recurso de estudio

File Handling in Python

Les recomiendo la siguiente extensión para VSCode la cúal nos permite ubicar un archivo de una manera un poquito más cómoda, los invito a probarla

Es un “Git” de Python.

Eso es una de las mayores ventajas de Platzi.
He aprendido por muchos medios. La mayoría en inglés. Esto significa que se suelen pasar el encoding como algo innecesario.
Pero si trabajas con archivos con datos en español, necesitas saber sobre encoding.

TIP Cuando coloca as “f” realmente lo que esta haciendo es una convencion es una forma de tener buenas practicas al momento de trabajar con archivos en python.

Para crear decenas de archivos a la vez:

def write():
    names = ["Ignacio","Daniel","Danan","Sophia","Marta","Dionisio","jesus"]
    variable = "./archivos/"
    numero = 0
    txt = ".txt"
    for i in range(100):
        numero = numero + 1
        total = variable +str(numero) +txt
        print(total)
        with open(total, "w", encoding = "utf-8") as f:
            for name in names:
                f.write(name)
                f.write("\n")





if __name__ =="__main__":
    write()

Hay un truco que se puede hacer cuando tienes una lista con muchos nombres y no quieres escribir tantas comillas:

names = “Paco Miguel Pepe Facundo Sebastian”.split()

lo que me encanta de estos cursos es que implementan todos los conocimientos pasados en cada tema en los que avanzan,es increible!!!

Si tiene problemas con las rutas relativas en windows pueden usar la librería os

import os

rutaDir = os.path.dirname(__file__)

def read():
    numbers = []
    rutaR = os.path.join(rutaDir, "archivos/numbers.txt")
    with open(rutaR, "r", encoding="utf-8") as f:
        for line in f:
            numbers.append(int(line))
    print(numbers)


def write():
    names = ["Facundo", "Gregorio", "Marta", "Susana", "Jose"]
    rutaW = os.path.join(rutaDir, "archivos/names.txt")
    with open(rutaW, "w") as f:
        for name in names:
            f.write(name)
            f.write("\n")


def run():
    # write()
    read()


if __name__ == '__main__':
    run()

Por si alguien también tuvo problemas con usar la ruta alternativa en Windows, yo la escribí de está forma y me funcionó.

with open("../Programas/archivos/numbers.txt" , "r") as  f:

Con doble .

def read():
    numbers = []
    with open("./archivos/numbers.txt", "r", encoding="utf-8") as f:
        for line in f:
            numbers.append(int(line))
    print(numbers)

def write():
    names = ["Daniel", "Miguel", "Pepe", "Christian", "Rocío"]
    with open("./archivos/names.txt", "w", encoding="utf-8") as f:
        for name in names:
            f.write(name)
            f.write("\n")

def run():
    write()

if __name__ == '__main__':
    run()

Con este código se pueden contar las ocasiones que aparece una cadena de caracteres específicas dentro de un archivo.
Combine el uso de archivos con el try/except, en caso de que no exista el archivo que especifico.

filename = 'deutschland.txt'
try:
    with open(filename, encoding='utf-8') as f:
        song = f.read()
except FileNotFoundError:
    print(f"The file {filename} does not exist.")
else:
    print(song.lower().count('du'))
    

Un aporte resumiendo todo lo tratado en la clase:
.

def read():
    numbers = []
    # Parameter "r" to only read a file
    with open("./numbers.txt", "r", encoding="utf-8") as f:
        for line in f:
            numbers.append(int(line))
        print(numbers)


def write():
    names = ["Alberto", "José", "Pablo", "Marcelo", "Pedro"]
    # with = prevents the file from breaking if the program closes unexpectedly
    # Parameter "w" to write or rewrite text in a file
    with open("./names.txt", "w", encoding="utf-8") as f:
        for name in names:
            f.write(name)
            f.write("\n")


def write_append():
    names = ["María", "Daniela", "Lucía", "Danna", "Andrea"]
    # Parameter "a" to append text in a file
    with open("./names.txt", "a", encoding="utf-8") as f:
        for name in names:
            f.write(name)
            f.write("\n")


def run():
    read()
    write()
    write_append()


if __name__ == "__main__":
    run()

def read():
    numbers = []

    with open("./archivos/numbers.txt", "r", encoding="utf-8") as f:
        for line in f:
            numbers.append(int(line))
    
    print(numbers)

def write():
    names = ["Carlos", "Miguel", "Carlos", "El pepe"]

    with open("./archivos/names.txt", "a", encoding="utf-8") as f:
        for name in names:
            f.write(name)
            f.write("\n")

def main():
    write()

if __name__ == "__main__":
    main()

Así lo hice usando list comprehensions:

def read():

    numbers = []

    with open('05_python_intermedio/modulo_VI_manejo_de_archivos/archivos/numbers.txt', 'r', encoding='utf-8') as f:
        [numbers.append(int(line)) for line in f]
    print(numbers)


def write():

    names = ['Andrea', 'Angel', 'Vicky', 'Elon']

    with open('05_python_intermedio/modulo_VI_manejo_de_archivos/archivos/names.txt', 'a', encoding='utf-8') as f:
        [f.write(name) and f.write('\n') for name in names]

def read():
    numbers = []
    with open("./archivos/numeros.txt", "r", encoding="utf-8") as f:
        for line in f:
            numbers.append(int(line))

        print(numbers)

def write():
    names = ["Sancho", "Panza", "Francisco", "Isabel", "Juanda", "Jonathan", "Rafael", "Almeida", "Andres", "Felix", "Petalos", "Carlos", "Fabio", "Tito", "Olga"]
    with open("./archivos/names.txt", "a", encoding="utf-8") as f:
        for name in names:
            f.write(name)
            f.write("\n")

def run():
    read()
    write()


if __name__ == ('__main__'):
    run()

Generar la lista de números a partir del achivo numbers.txt
utilizando map y lambda en una sola línea.

number = list( 
        map(
            lambda x: int(x.strip()), 
            open("./Archivos/numbers.txt", "r", encoding='utf-8').read().split("\n")
        )
     )

En la función write() podemos castear la variable _name _ utilizando f-strings.

f.write(f"{name}\n")

def write():
    names = ["Facundo", "Miguel", "Pepe", "Christian", "Rocío"]
    with open('./archivos/names.txt', 'w', encoding='utf-8') as f:
        for name in names:
            f.write(f"{name}\n")

Espero que sea de ayuda.
Saludos.

Teniendo en cuenta todo lo anterior, tenemos que dentro de nuestra función open, podemos poner un parámetro: encoding="utf-8" para que los casos de caracteres extraños, no nos perjudiquen.

<def reading():
    edades = []
    with open ("./Manejo de archivos/edades.txt" ,"r", encoding="utf-8") as f:
        edades = [int(line) for line in f]
    print(edades)> 

Antes abria los archivos de la manera “antigüa” como

f = open("rta/archivo.txt","r")
#Hacer algo con el archivo
f.close()

Se supone que python cierra el buffer del archivo si ocurre una exepción y f.close() ni si quiera es obligatorio pero sí es una buena práctica cerrarlo. Pero usar la estructura with es mejor.

😍

def read():
    try:
        with open('./files/numbers.txt', 'r', encoding='utf-8') as file:
            return [int(l) for l in file]
    finally:
        file.close()

def write(read):
    try:
        with open('./files/numbers-sqr.txt', 'w', encoding='utf-8') as file:
            file.writelines([
                '     x    |  f(x) = x^2    \n',
                '---------------------------\n'
            ])
            for n in read:
                file.writelines([
                    '     {row}    |    {sqr}    \n'.format(row=n, sqr=n**2),
                    '---------------------------\n',
                ])
    finally:
        file.close()

def run():
    res = read()
    write(res)

if __name__ == "__main__":
    run()

Entendido, vamos por el reto

def read():
    numbers = []
    with open("./archivos/numbers.txt","r",encoding="utf-8") as f:
        for line in f:
            numbers.append(int(line))
            #print(line.strip())

    print(numbers)


def write():
    names = ["David","Diana","Ana Maria","Isabela","Doña C", "Andres Felipe", "Jasper", "Alaska", "Andreco", "Antonio", "Norma"]
    with open("./archivos/names.txt","w",encoding="utf-8") as w:
        for name in names:
            w.write(name)
            w.write("\n")

#Sin sobreescribir,agregando al final
def write2():
    names = ["David","Diana","Ana Maria","Isabela","Doña C", "Andres Felipe", "Jasper", "Alaska", "Andreco", "Antonio", "Norma"]
    with open("./archivos/names.txt","a",encoding="utf-8") as w:
        for name in names:
            w.write(name)
            w.write("\n")


def run():
    write()



if __name__=='__main__':
    run()

Les agrego un par de funciones con métodos para crear, eliminar y leer archivos (este desde la consola). Saludos!:

def create():
    file_name = input("Please enter the file name: ")
    with open("./files/" + file_name + ".txt", "x") as f:
        pass
    f.close()


def delete():
    import os
    print(os.listdir("./files/"))
    file_name = input("Please enter the file name: ")
    os.remove(f'./files/{file_name}')


def another_read():
    with open('./files/file.txt') as f:
        print(f.read())
        f.close()

def read():
    names = []
    with open("jcor.txt", "r", encoding="utf-8") as f:
        for line in f:
            if len(line.strip()) > 0:
                names.append(line.strip())
    if len(names) > 0:
        print(names)
    else:
        print("Archivo vacio")


def write():
    names = []
    with open("jcor.txt", "w", encoding="utf-8") as f:
        for name in names:
            f.write(name)
            f.write('\n')


def agregar_nombre(nombre):
    with open("jcor.txt", "a", encoding="utf-8") as f:
        f.write(nombre)
        f.write("\n")


def borrar_nombre(nombre):
    names = []
    with open("jcor.txt", "r", encoding="utf-8") as f:
        for line in f:
            if len(line.strip()) > 0 and line.strip() != nombre:
                names.append(line.strip())
    with open("jcor.txt", "w", encoding="utf-8") as f:
        for name in names:
            f.write(name)
            f.write('\n')


def run():
    sw = True
    while sw:
        try:
            print("""  
----------------------------------------------------------------------
            Seleccione un numero:
            1. Crear un nuevo archivo 
            2. Agregar nombre
            3. Listar nombre
            4. Borrar nombre
            5. Salir del programa
----------------------------------------------------------------------
            """)
            n = int(input("Ingrese una opcion :   "))
            if n == 1:
                write()
            elif n == 2:
                nombre = input("Ingrese el nombre a agregar: ")
                agregar_nombre(nombre)
            elif n == 3:
                read()
            elif n == 4:
                nombre = input("Ingrese el nombre a borrar : ")
                borrar_nombre(nombre)
            elif n == 5:
                sw = False
                print("Programa Terminado!")
        except ValueError:
            print("Error seleccione una opcion correcta")
    # write()


if __name__ == '__main__':
    run()

Gracias al aporte de un companero ahi estuve entretenido tratando de entender lo mismo

def read():

    names = []
    with open("./archives/name.txt", "r", encoding="utf-8") as f:
        for line in f:
            # strip() is used to delete spaces in the line
            if len(line.strip()) > 0:
                names.append(line.strip())
            if len(names) > 0:
                print(names)

            else:
                print("Archivo vacio")


def write(texto):
    names = [texto]
    with open("./archives/new.txt", "w", encoding="utf-8") as f:
        for name in names:
            f.write(name)
            f.write("\n")


def add_name(name):
    with open("./archives/name.txt", "a", encoding="utf-8") as f:
        f.write(name)
        f.write("\n")


def delete_name(name):
    pass


def run():
    start_program = True
    while start_program:
        try:
            print(
                """ 
            ----------------------------------------------------------------------
                Seleccione un numero:
                1. Crear un nuevo archivo 
                2. Agregar nombre
                3. Listar nombre
                4. Salir del programa
            ----------------------------------------------------------------------
            """
            )

            n = int(input("Ingrese un valor: "))

            if n == 1:
                texto = input("Ingresa un texto: ")
                write(texto)

            elif n == 2:
                name = input("Ingrese un nombre: ")
                add_name(name)

            elif n == 3:
                read()

            elif n == 4:
                start_program = False
                print("Gracias por usar el programa")

        except ValueError:
            print("Error, seleccione una opcion valida")


if __name__ == "__main__":
    run()

Para lo que tengan linux o wsl, copien y jecuten este pequeño script en terminal 😃

#!/bin/bash
for i in {1..100}
do
    echo $(($RANDOM%100)) >> ./numbers.txt
done

Nota

• Usamos el parámetro encoding = "utf-8" de open para trabajar con caracteres especiales del español (ñ, tildes, etc)

Modo Notas
r el archivo se abre en modo de solo lectura,
no se puede escribir (argumento por
defecto).

w modo de solo escritura (si existe un
archivo con el mismo nombre, se borra).

a modo de agregado (append), los datos
escritos se agregan al final del archivo.

r+ el archivo se abre para lectura y escritura
al mismo tiempo.

b el archivo se abre en modo binario, para
almacenar cualquier cosa que no sea
texto.

U el archivo se abre con soporte a nueva
linea universal, cualquier fin de linea
ingresada sera como un \n en Python.

El siguiente código es para obtener en una lista los nombres de los archivos que se encuentran dentro de una carpeta, debido a que en muchas ocaciones cambian los nombres de los archivos y requerimos cargar el mismo siempre, espero les sirva:

import os
lista_archivos = os.listdir()

A mí me está escribiendo los acentos inclusive la ñ sin la necesidad de usar encoding=“utf-8”.
La versión que tengo de python es:
3.9.6 (64bit) corriendo en Mac.
Espero que ayude.
Saludos

Resumen de esta clase:

def read():
    # Leemos archivo que  contiene solo numeros
    with open("numbers.txt", "r", encoding="utf-8") as file:
        numbers = [int(line) for line in file]
    print(numbers)
    
def write():
    # Guardamos esta lista en un txt
    names = ["Kenyi", "Julberht", "Hancco", "Quispe"]
    with open("wirte.txt", "w", encoding="utf-8") as file:
        for name in names:
            file.write(f"{name}\n")

def run():
    write()

if __name__ == '__main__':
    run()

Mi breve ejemplo

def read_numbers():
    numbers = []
    with open("./numbers.txt", "r", encoding="utf-8") as my_file:
        numbers = [int(line) for line in my_file]
    print(numbers)

def read_file(path):
    elements = []
    with open(path, "r", encoding="utf-8") as my_file:
        elements = [element for element in my_file]
    print(elements)

def write_file(path, elements):
    with open(path, "w+", encoding="utf-8") as f:
        for element in elements:
            f.write(element)
            f.write("\n")

def add_names(names):
    with open("./names.txt", "a",encoding="utf-8") as my_file:
        for name in names:
            my_file.write(name)
            my_file.write("\n")


def run():
    try:
        # read_numbers()
        # add_names(["John Doe", "Jane Doe", "Rocío Doe"])
        # read_file("./names.txt")
        write_file("./ingredients", ["eggs","milk","flour"])
        read_file("./ingredients")
    except FileNotFoundError as error:
        print(error)

if __name__=='__main__':
    run()

Para asegurarnos de que lo que vayamos a leer no tenga caracteres extraños, podemos utilizar:

encoding="utf-8"

Para un menu rapido

from consolebox.menubox import MenuBox # pip install consolebox
from consolebox.style import Style
import colorama # pip install colorama

def about():
    print("Programed by JordyM01")

def your_options():
    print("create a function for each option in your menu")
    a = 5
    b = 6
    print(f'addition: {a + b}')

def main():
    items = { # Menu options
        1 : "Option 1",
        2 : "About"
        }

    options = { # functions that correspond to the menu options the numeric identifier must be the same
        1 : your_options, # function name without parentheses
        7: about,
    }

    attributes = {
            "length" : 40, # Broad min 40 max 90
            "columns" : 1, # Max = 5
            "indicator" : ">>", # ==>, *, -, ::, +, @
            "alignment" : "centered", # Right, left, centered
            "enumerate" : True, # True or False
            "title" : True, # True or False
            "Title" : "Menu options", # Title text max 36 characters title must be True
            "corner" : True, # True or False
            "intersection" : True, # Intersection True or False
    }
    # use tab, directional arrows and enter to scroll, backspace to exit

    men = MenuBox(items, attributes, options)

    Style.clear() # Clean screen
    men.show() # show the menu object


if __name__ == '__main__':
    main()

encoding para interpretar caracteres en español

Ya quedo el manejo de archivos

Hice una pequeña agenda de contactos con las funciones de agregar y eliminar XD
Es simple pero con esfuerzo 😄
Les dejo un gif de como funciona y el código más abajo

import os
FILE_PATH = os.path.dirname(__file__)


def delete():
    contacts = []
    i = -1

    with open(FILE_PATH + "/txt/contacts.txt", "r", encoding="utf-8") as f:
        contacts = [contact for contact in f]

        for contact in contacts:
            print(contact)

        delete_contact = input(
            "Ingresa el ID (número) del contacto a eliminar: ")

        for line in contacts:
            contact = line.split()
            num = contact[0]

            if num == delete_contact:
                i = contacts.index(line)
                contacts.pop(i)
                break
    if i != -1:
        with open(FILE_PATH + "/txt/contacts.txt", "w", encoding="utf-8") as f:
            num = 0
            for contact in contacts:
                num += 1
                contact = " ".join(contact.split()[1:])
                f.write(str(num) + " " + contact + "\n")
    else:
        print("No hay un contacto con ese ID")


def add():
    with open(FILE_PATH + "/txt/contacts.txt", "a", encoding="utf-8") as f:
        num = line_count() + 1
        name = input("Nombre: ")
        last_name = input("Apellido: ")
        tel = input("Teléfono: ")

        f.write(str(num) + " " + name + " " + last_name + " " + tel + "\n")


def line_count():
    lines = 0
    with open(FILE_PATH + "/txt/contacts.txt", "r", encoding="utf-8") as f:
        for line in f:
            lines += 1
    return lines


def run():
    x = input("1: agregar\n2: eliminar\n-> ")
    if x == "1":
        add()
    else:
        delete()


if __name__ == '__main__':
    run()

No sé por qué pero en Visual Studio Code no pude realizar el primer ejercicio que consistia en leer el .txt e imprimirlo en forma de lista, lo corri en PyCharm y allí si

Por si alguien más tiene el mismo problema espero le funcione

Un uso muy util de esto es registro de los scripts que corren

with open("./archivos/numbers.txt", “r”, encoding=“utf-8”) as f:
print([int(line) for line in f])
También se puede hacer con list comprehension.

import os
def cls():
    os.system('cls' if os.name=='nt' else 'clear')
    
def name_exists(name):
    names = []
    name = str(name).lower()
    names = list(map(lambda n: n.lower(), read(False)))

    return name in names

def create():
    name = ''
    while name == '':
        name = input('New name: ').capitalize()
    
    if not name_exists(name):
        with open('./names_files/names.txt', 'a', encoding='utf-8') as f:
            f.write(f"{name}\n")
        print(f'{name} was added!')
    else:
        print(f'{name} already exists!')
    
def read(display=True):
    lines = []
    with open('./names_files/names.txt', 'r', encoding='utf-8') as f:        
        for line in f:
            lines.append(line.rstrip())
            if display:
                print(line.rstrip())
                
    return lines
    
def update():
    name_to_update = ''
    while name_to_update == '':
        name_to_update = input('Name to update: ').capitalize()
        
    if name_exists(name_to_update):
        names = read(False)
        name_inx = names.index(name_to_update)
        names[name_inx] = input(f'New name to {name_to_update}: ').capitalize()
        with open('./names_files/names.txt', 'w', encoding='utf-8') as f:        
            for name in names:
                f.write(f"{name}\n")
        print(f'{name_to_update} was updated to {names[name_inx]}.')
    else:
        print(f'{name_to_update} not exists on file.')
    
def delete():
    name_to_delete = ''
    while name_to_delete == '':
        name_to_delete = input('Name to delete: ').capitalize()
        
    if name_exists(name_to_delete):
        names = read(False)
        with open('./names_files/names.txt', 'w', encoding='utf-8') as f:        
            for name in names:
                if name != name_to_delete:
                    f.write(f"{name}\n")
        print(f'{name_to_delete} was deleted.')
    else:
        print(f'{name_to_delete} not exists on file.')

DICT_FUNCTS = {
    0: lambda: print('Invalid option.'),
    1: create,
    2: read,
    3: update,
    4: delete,
}

DICT_TITLES = {
    0: lambda: print('[ ERROR ]:\n'),
    1: lambda: print('[ CREATE Function]:\n'),
    2: lambda: print('[ READ Function]:\n'),
    3: lambda: print('[ UPDATE Function]:\n'),
    4: lambda: print('[ DELETE Function]:\n'),
}

def display_menu():
    print('[ CRUD USING FILES ]\n\n1) Create\n2) Read\n3) Update\n4) Delete\n')
    option = input('Select an option: ')
    cls()
    return option if option.isdigit() and int(option) in DICT_FUNCTS else 0

if __name__ == '__main__':
    option = None
    while option != 99:
        cls()
        option = int(display_menu())
        DICT_TITLES[option]()
        DICT_FUNCTS[option]()
        input('\nPress enter to continue...')

Estaba usando python en el subsistema de linux para Windows y me encontre con el error este

Descubri que el problema era el enconding de mi archivo.
Para solucionarlo pueden dar ctrl+shift+p buscar encoding y les dara unas opciones para guardar el archivo correctamente o pueden cambiar los defaults en la configuracion de VSCode.

Espero que le sirva a mas de uno 😀

ABRIR ARCHIVOS DE TEXTO CON PYTHON

with open("/path/file.txt", "r", encoding="utf-8") as f

with para proteger el archivo en caso de que se cierre inesperadamente.

open para abrirlo, tiene los parámetros obligatorios (dirección del archivo, modo {r, w, a))

as para asignar un nombre al archivo (convertirlo en una variable de nuestro programa.

ara escribir o leer cadenas de caracteres para/desde archivos (otros tipos deben ser convertidas a cadenas de caracteres). Para esto Python incorpora un tipo integrado llamado file, el cual es manipulado mediante un objeto archivo el cual fue generado a través de una función integrada en Python, a continuación se describen los procesos típicos y sus referencias a funciones propias del lenguaje:
7.2.1. Abrir archivo

La forma preferida para abrir un archivo es usando la función integrada open().
7.2.2. Leer archivo

La forma preferida para leer un archivo es usando algunas de los métodos del tipo objeto file como read(), readline() y readlines().
7.2.3. Escribir archivo

La forma preferida para escribir un archivo es usando el método del tipo objeto file llamado write().
7.2.4. Cerrar archivo

La forma preferida para cerrar un archivo es usando el método del tipo objeto file llamado close().
7.2.5. Archivos con modulo os

El módulo os de Python le permite a usted realizar operaciones dependiente del Sistema Operativo como crear una carpeta, listar contenidos de una carpeta, conocer acerca de un proceso, finalizar un proceso, etc. Este módulo tiene métodos para ver variables de entornos del Sistema Operativo con las cuales Python esta trabajando en mucho más. Aquí la documentación Python para el módulo os.

A continuación algunos útiles métodos del módulo os que pueden ayudar a manipular archivos y carpeta en su programa Python:

Crear una nueva carpeta

import os
os.makedirs(“Ana_Poleo”)

Listar el contenidos de una carpeta

import os
os.listdir("./")
[‘Ana_Poleo’]

Mostrar el actual directorio de trabajo

import os
os.getcwd()
’/home/usuario/python/’

Mostrar el tamaño del archivo en bytes del archivo pasado en parámetro

import os
os.path.getsize(“Ana_Poleo”)
4096

¿Es un archivo el parámetro pasado?

import os
os.path.isfile(“Ana_Poleo”)
False

¿Es una carpeta el parámetro pasado?

import os
os.path.isdir(“Ana_Poleo”)
True

Cambiar directorio/carpeta

import os
os.chdir(“Ana_Poleo”)
os.getcwd()
’/home/usuario/python/Ana_Poleo’

os.listdir("./")
[]

os.chdir("…/")
os.getcwd()
’/home/usuario/python’

Renombrar un archivo

import os
os.rename(“Ana_Poleo”,“Ana_Carolina”)
os.listdir("./")
[‘Ana_Carolina’]

Eliminar un archivo

import os
os.chdir(“Ana_Carolina”)
archivo = open(os.getcwd()+’/datos.txt’, ‘w’)
archivo.write(“Se Feliz!”)
archivo.close()
os.getcwd()
’/home/usuario/python/Ana_Carolina’

os.listdir("./")
[‘datos.txt’]

os.remove(os.getcwd()+"/datos.txt")
os.listdir("./")
[]

Eliminar una carpeta

os.rmdir(“Ana_Carolina”)
os.chdir(“Ana_Carolina”)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
OSError: [Errno 2] No such file or directory: ‘Ana_Carolina’

Lanza una excepción OSError cuando intenta acceder al directorio que previamente elimino y este no encuentra.

Hace un tiempo necesite obtener los datos de unos QR para compararlos con unos datos en mysql, capture la salida de un programa llamado zbarcam en un archivo texto de la forma ./zbarcam >> datos.txt. puede usarse con algunos dispositivos de código de barras.

from time import sleep

def read():
    numbers=[]
    with open("./numbers.txt", "r", encoding="utf-8") as f:
        numbers=list(f)
        return numbers

 
def write():
    pass


def run():
    old_lines = 0
    while True:
        numbers=read()
        
        if len(numbers) > old_lines:
            print(numbers[len(numbers)-1])
            old_lines = len(numbers)
            
        sleep(0.5)
    
if __name__=='__main__':
    run()
    

Este curso fue un abrir y cerrar de ojos , que calidad de profesor!

ARCHIVO DE TEXTO CON PYTHON

Si te da el error que no encuentra el archivo, da click derecho en el archivo objetivo y copia la ruta relativa (relative path)
.
Si te da error de unicode, o te dice error de argumento invalido por más que la ruta este bien:

open(r'TuDirectorio\archivos\numbers.txt','r',encoding='utf-8')

agrega una r antes de la ruta del archivo

Para windows, no es necesario el punto, basta con poner la carpeta y el nombre del archivo.

Hola, estoy trabajando con VSCode y he notado en la termianl, que en algunas ocaciones las rutas las pone con / y en otras ocaciones , cual es la diferencia?

Podemos usar enconding desde el inicio del programa en python

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def read():
    numbers = []
    with open("./archivos/numbers.txt", "r", encoding="utf-8") as f:
        for line in f:
            numbers.append(int(line))
        print(numbers)


def write():
    names = ["Néstor", "Enrique", "Juan", "María"]
    # with open("./archivos/names.txt", "w", encoding="utf-8") as f:
    with open("./archivos/names.txt", "a", encoding="utf-8") as f:
        for name in names:
            f.write(name)
            f.write("\n")


def run():
    # read()
    write()

if __name__ == '__main__':
    run()

El codigo de la clase con list comprehensions y reutilizando las funciones creadas para la lectura y escritura de los archivos.

import os

PATH=os.path.dirname(__file__)

def read(filename):
    my_list = []
    try:
        print(f'Leyendo el archivo "{filename}".')
        with open(f'{PATH}/files/' + filename, 'r', encoding='utf-8') as f:
            my_list = [line.strip() for line in f]
        print(' ', my_list)
    except FileNotFoundError:
        print(f'El archivo "{filename}" no existe!')

def write(filename, list_value):
    try:
        with open(f'{PATH}/files/names.txt', 'w', encoding='utf-8') as f:
            for value in list_value:
                f.write(value)
                f.write('\n')
            f.close()
        print(f'Fue creado el archivo "{filename}" con los siguientes datos:\n  {list_value}')
    except FileNotFoundError:
        print(f'El archivo "{filename}" no existe!')        

def run():
    names = ['Francisco', 'Alex', 'Kaviana', 'María', 'Jose']
    print('Lectura y Escritura de Archivos\n')
    read('numbers.txt')    
    write('names.txt', names)
    read('names.txt')


if __name__ == "__main__":
    run()

aaa

<print ("Hello")> 

Excelente clase.

Por si a alguien le sirve (yo no lo sabía), el script no funciona si en el .txt de números hay líneas vacías entre un número y otro

recuerden una buena práctica es siempre cerrar sus archivos al terminar la ejecución del programa
tambien cerrar el archivo cuando ya no lo usaremos mas

Si no existe un archivo que abrimos, este lo crea.

Los archivos pueden ser utilizados como iterables. De forma que podemos ciclar sobre ellos.

Por si le sirve de ayuda a alguien que tenga el mismo erro.
Yo estoy trabajando con wsl en windows y me sale un error que no encuentra el archivo lo solucioné usando la ruta absoluta al archivo en lugar de una relativa.

Un tanto similar a lo que viene a ser unir un CSS con un HTML, buena clase. esto para mi sigue siendo un 10/10.

Excelente , gracias

Error desbloqueado!

LookupError: unknown encoding: uft-8

El código de la clase aplicando list comprehension

def read():
    with open('./archivos/numbers.txt', 'r', encoding='utf-8') as f:
        numbers = [int(line) for line in f]
    print(numbers)
    


def write():
    names = ['Tito', 'Jose', 'Ñeka', 'Michi']
    with open('./archivos/name.txt', 'w', encoding='utf-8') as f:
        [f.write(name+'\n') for name in names]


def main():
    write()


if __name__=='__main__':
    main()