Categorías
Python

La última guía para Reconocimiento de voz con Python

 

Tabla de Contenidos

  • Qué es un archivo? Archivo PathsLine EndingsCharacter codificaciones
  • Archivo Caminos
  • Línea Endings
  • codificaciones de caracteres
  • Abrir y cerrar un archivo en PythonText archivos TypesBuffered binarios Tipos TypesRaw al archivo
  • Tipos de archivo de texto
  • tamponada binarios Tipos de archivo
  • primas Tipos de archivo
  • lectura y escritura Abierto FilesIterating sobre cada línea en el FileWorking Con BytesA Ejemplo completo: dos2unix.py
  • iteración en cada línea en el archivo
  • Trabajo con bytes de
  • un ejemplo completo : dos2unix.py
  • Consejos y Tricks__file__Appending a un dos archivos FileWorking con el mismo TimeCreating su propio contexto Gestor
  • __FILE__
  • Anexión a un archivo
  • con dos archivos de trabajo en el mismo tiempo
  • Creación de su propio contexto Gestor
  • no vuelva a inventar la serpiente
  • Eres un archivo de Asistente Harr y!
  • Archivo Caminos
  • Línea Endings
  • codificaciones de caracteres
  • Tipos de archivo de texto
  • tamponada binarios Tipos de archivo Tipos de archivo
  • primas
  • iteración en cada línea en el archivo
  • Trabajo con bytes de
  • un ejemplo completo: dos2unix.py
  • __file__
  • Anexión a un archivo
  • con dos archivos de trabajo en el mismo tiempo
  • Creación de su propio contexto Gestor

Mira ahora Este tutorial tiene un vídeo relacionado curso creado por el verdadero equipo de Python. Mira que junto con el tutorial escrito para profundizar su comprensión: de lectura y escritura de archivos en Python

Una de las tareas más comunes que se pueden hacer con Python es la lectura y escritura de archivos. Ya se trate de escribir en un archivo de texto simple, la lectura de un registro del servidor complicado, o incluso el análisis de datos byte primas, todas estas situaciones requieren la lectura o la escritura de un archivo.

En este tutorial, aprenderá:

  • ¿Qué compone un archivo y por qué es importante en Python
  • Los conceptos básicos de lectura y escritura de archivos en Python
  • Algunos escenarios básicos de lectura y escritura de archivos

Este tutorial es principalmente para el principiante a intermedio Pythonistas, pero hay algunos consejos aquí que los programadores más avanzados pueden apreciar también. Bono

gratuito: Haga clic aquí para obtener nuestro libre Hoja de trucos Python que le muestra los conceptos básicos de Python 3, como trabajar con tipos de datos, diccionarios, listas y funciones de Python.

Tome el Cuestionario: Prueba sus conocimientos con nuestro sistema interactivo “Lectura y escritura de archivos en Python” cuestionario. Al finalizar, recibirá una puntuación para que pueda controlar su progreso en el aprendizaje a través del tiempo:

Contesta la trivia »

Qué es un archivo?

Antes de que podamos entrar en la forma de trabajar con archivos en Python, es importante entender qué es exactamente un archivo es y cómo los sistemas operativos modernos manejan algunos de sus aspectos.

En su esencia, un archivo es un conjunto contiguo de bytes utilizados para almacenar datos. Estos datos se organiza en un formato específico y puede ser cualquier cosa tan simple como un archivo de texto o tan complicado como un programa ejecutable. Al final, estos archivos byte se traducen luego en binario 1 y 0 para un procesamiento más fácil por el ordenador.

archivos en la mayoría de los sistemas de archivos modernos están compuestos de tres partes principales:

Lo que esto representa los datos depende de la especificación del formato utilizado, que por lo general está representado por una extensión. Por ejemplo, un archivo que tiene una extensión de la mayoría .gif ajusta probable que la especificación de formato de intercambio de gráficos. Hay cientos, si no miles, de extensiones de archivo que hay. Para este tutorial, sólo se va a lidiar con el archivo .txt o .csv extensiones.

Caminos

archivos

Cuando acceda a un archivo en un sistema operativo, se requiere una ruta de archivo. La ruta del archivo es una cadena que representa la ubicación de un archivo. Está dividido en tres partes principales:

Aquí está un ejemplo rápido. Digamos que usted tiene un archivo que se encuentra dentro de una estructura de archivos como esto: digamos de

/

├── path/
| │
│ ├── to/
│ │ └── cats.gif
│ │
│ └── dog_breeds.txt
|
└── animals.csv

permiten quería acceder al archivo cats.gif, y su ubicación actual estaba en la misma carpeta que camino. Con el fin de acceder al fichero, tiene que ir a través de la carpeta de la ruta y luego el de la carpeta, finalmente, llegar al archivo cats.gif. La Ruta de la carpeta es ruta / a /. El nombre del archivo es gatos. La extensión del archivo es gif. Por lo que la ruta completa es ruta / a / cats.gif.

Ahora vamos a decir que su ubicación actual o el directorio de trabajo actual (CWD) se encuentra en la carpeta de ejemplo de nuestra estructura de carpetas. En lugar de referirse a la cats.gif de la ruta completa de la ruta / a / cats.gif, el archivo puede ser simplemente referenciada por el nombre de archivo y extensión cats.gif.

/

├── path/
| │
| ├── to/ ← Your current working directory (cwd) is here
| │ └── cats.gif ← Accessing this file
| │
| └── dog_breeds.txt
|
└── animals.csv

Pero ¿qué pasa con dog_breeds.txt? ¿Cómo se accede a que sin necesidad de utilizar la ruta completa? Puede utilizar los caracteres especiales de doble punto (..) para mover un directorio arriba. Esto significa que ../dog_breeds.txt hará referencia al archivo dog_breeds.txt desde el directorio de a:

/

├── path/ ← Referencing this parent folder
| │
| ├── to/ ← Current working directory (cwd)
| │ └── cats.gif
| │
| └── dog_breeds.txt ← Accessing this file
|
└── animals.csv

El doble punto (..) se pueden encadenar juntos para atravesar múltiples directorios por encima del directorio actual. Por ejemplo, el acceso a animals.csv de la carpeta a, utilizaría ../../animals.csv.

Línea Endings

Un problema frecuente cuando se trabaja con datos de archivo es la representación de una nueva línea o final de línea. El final de línea tiene sus raíces en la época de código Morse, cuando se utilizó un pro-signo específico para comunicar el final de una transmisión o al final de una línea.

Más tarde, esto era st y ardized de teletipos por tanto la Organización Internacional para St y ardization (ISO) y la American St y SDRA Asociación (ASA). ASA st y ard estados que los finales de línea debe utilizar la secuencia del retorno de carro (CR o \ r) y el avance de línea (LF o \ n) caracteres (CR + LF o \ r \ n). El st ISO y ard embargo permitidas para cualquiera de los caracteres CR + LF o simplemente el carácter LF.

Windows utiliza los caracteres CR + LF para indicar una nueva línea, mientras que Unix y las versiones más recientes de Mac utilizan sólo el carácter LF. Esto puede causar algunas complicaciones cuando se está procesando archivos en un sistema operativo que es diferente de la fuente del archivo. Aquí hay un ejemplo rápido. Vamos a decir que examinamos el dog_breeds.txt archivo creado en un sistema Windows:

Pug\r\n
Jack Russell Terrier\r\n
English Springer Spaniel\r\n
German Shepherd\r\n
Staffordshire Bull Terrier\r\n
Cavalier King Charles Spaniel\r\n
Golden Retriever\r\n
West Highland White Terrier\r\n
Boxer\r\n
Border Terrier\r\n

Este mismo resultado se puede interpretar en un dispositivo diferente Unix:

Pug\r
\n
Jack Russell Terrier\r
\n
English Springer Spaniel\r
\n
German Shepherd\r
\n
Staffordshire Bull Terrier\r
\n
Cavalier King Charles Spaniel\r
\n
Golden Retriever\r
\n
West Highland White Terrier\r
\n
Boxer\r
\n
Border Terrier\r
\n

Esto puede hacer que la iteración sobre cada línea de problemática, y es posible que necesite dar cuenta de situaciones como esta.

codificaciones de caracteres

Otro problema común que puede enfrentar es la codificación de los datos byte. Una codificación es una traducción de los datos byte a caracteres legibles por humanos. Esto normalmente se realiza mediante la asignación de un valor numérico para representar un carácter. Los dos más comunes son codificaciones ASCII y Unicode formatos. ASCII sólo puede almacenar 128 caracteres, mientras que Unicode puede contener hasta 1,114,112 caracteres.

ASCII es en realidad un subconjunto de Unicode (UTF-8), lo que significa que la cuota ASCII y Unicode la misma numérica de los valores de caracteres. Es importante señalar que el análisis de un archivo con la codificación de caracteres incorrecto puede dar lugar a fallos o mala representación del personaje. Por ejemplo, si un archivo fue creado utilizando la codificación UTF-8, y se intenta analizar utilizando la codificación ASCII, si hay un personaje que se encuentra fuera de esos 128 valores, entonces se produce un error.

abrir y cerrar un archivo en Python

Cuando se desea trabajar con un archivo, lo primero que hay que hacer es abrirlo. Esto se hace mediante la invocación del open () función incorporada. open () tiene un solo argumento de que se requiere es la ruta de acceso al archivo. open () tiene un solo cambio, el objeto de archivo:

file = open('dog_breeds.txt')

Después de abrir un archivo, el siguiente paso es aprender cómo cerrar la misma.

Advertencia: usted debe siempre asegurarse de que un archivo abierto se cierra correctamente.

Es importante recordar que es su responsabilidad para cerrar el archivo. En la mayoría de los casos, a la terminación de una aplicación o un script, un archivo se cerrará con el tiempo. Sin embargo, no hay garantía de cuándo exactamente que va a pasar. Esto puede conducir a un comportamiento no deseado, incluidos las pérdidas de recursos. También es una buena práctica dentro de Python (Pythonic) para asegurarse de que sus códigos se comporta de una manera que está bien definido y reduce cualquier comportamiento no deseado.

Cuando se está manipulando un archivo, hay dos maneras que usted puede utilizar para asegurarse de que un archivo se cierra correctamente, incluso cuando se enfrentan a un error. La primera manera de cerrar un archivo es utilizar el try-finally:

reader = open('dog_breeds.txt')
try:
# Further file processing goes here
finally:
reader.close()

Si no está familiarizado con lo que el bloque try-finally es, echa un vistazo a excepciones Python: Una introducción.

La segunda manera de cerrar un archivo es utilizar la sentencia with:

with open('dog_breeds.txt') as reader:
# Further file processing goes here

La sentencia with automáticamente se encarga de cerrar el archivo una vez que sale del bloque with, incluso en caso de error. Le recomiendo que utilice la sentencia with tanto como sea posible, ya que permite un código más limpio y hace que el manejo de los errores inesperados más fácil para usted.

más probable es que también querrá utilizar el segundo argumento posicional, de modo. Este argumento es una cadena que contiene varios caracteres para representar la forma en que desea abrir el archivo. El valor por defecto y la más común es la ‘r’, que representa a abrir el archivo en modo de sólo lectura como un archivo de texto:

with open('dog_breeds.txt', 'r') as reader:
# Further file processing goes here

Otras opciones para los modos están completamente documentadas en línea, pero los más utilizados son los siguientes:

Let de volver a hablar un poco acerca de los objetos de archivo. Un objeto de archivo es:

“un objeto de una API orientada a archivos (con métodos como la lectura (o escritura) ()) a un recurso subyacente.” (Fuente)

Hay tres categorías diferentes de objetos de archivo: Archivos

  • texto
  • búfer binario archivos binarios
  • Ficheros

Cada uno de estos tipos de archivo se definen en el módulo io. He aquí un resumen rápido de cómo todo se alinea.

Tipos de archivo de texto archivo de texto

A es el archivo más común que te vas a encontrar. Aquí están algunos ejemplos de cómo se abren estos archivos:

open('abc.txt')

open('abc.txt', 'r')

open('abc.txt', 'w')

con este tipo de archivos, abierta () devolverá un objeto de archivo TextIOWrapper:

>>> file = open('dog_breeds.txt')
>>> type(file)

Este es el objeto de archivo predeterminado devuelto por open ().

tamponada binarios Tipos de archivo

con búfer, tipo de archivo binario se utiliza para leer y escribir archivos binarios. Aquí están algunos ejemplos de cómo se abren estos archivos:

open('abc.txt', 'rb')

open('abc.txt', 'wb')

Con estos tipos de archivos, abierta () devolverá ya sea un objeto de archivo BufferedReader o BufferedWriter: Tipos de archivo

>>> file = open('dog_breeds.txt', 'rb')
>>> type(file)

>>> file = open('dog_breeds.txt', 'wb')
>>> type(file)

primas

Un tipo de archivo en bruto es:

“ se utiliza generalmente como un bloque de construcción de bajo nivel para los flujos binarios y de texto “. (Fuente)

lo tanto, no suele utilizar.

Aquí está un ejemplo de cómo se abren estos archivos:

open('abc.txt', 'rb', buffering=0)

Con estos tipos de archivos, abiertos () devolverá un fichero objeto FileIO:

>>> file = open('dog_breeds.txt', 'rb', buffering=0)
>>> type(file)

lectura y escritura archivos abiertos

Una vez que haya abierto un archivo, usted querrá leer o escribir en el fichero. En primer lugar, vamos a cubrir la lectura de un archivo. Hay varios métodos que pueden ser llamados en un objeto de archivo para ayudarle a salir:

Usando el mismo archivo dog_breeds.txt que utilizó anteriormente, vamos a ir a través de algunos ejemplos de cómo utilizar estos métodos. Aquí está un ejemplo de cómo abrir y leer el archivo completo utilizando .read ():

>>> with open('dog_breeds.txt', 'r') as reader:
>>> # Read & print the entire file
>>> print(reader.read())
Pug
Jack Russell Terrier
English Springer Spaniel
German Shepherd
Staffordshire Bull Terrier
Cavalier King Charles Spaniel
Golden Retriever
West Highland White Terrier
Boxer
Border Terrier

He aquí un ejemplo de cómo leer 5 bytes de una línea cada vez utilizando la .readline Python () Método:

>>> with open('dog_breeds.txt', 'r') as reader:
>>> # Read & print the first 5 characters of the line 5 times
>>> print(reader.readline(5))
>>> # Notice that line is greater than the 5 chars and continues
>>> # down the line, reading 5 chars each time until the end of the
>>> # line and then "wraps" around
>>> print(reader.readline(5))
>>> print(reader.readline(5))
>>> print(reader.readline(5))
>>> print(reader.readline(5))
Pug

Jack
Russe
ll Te
rrier

He aquí un ejemplo de cómo leer el archivo completo como una lista con los .readlines Python () método:

>>> f = open('dog_breeds.txt')
>>> f.readlines() # Returns a list object
['Pug\n', 'Jack Russell Terrier\n', 'English Springer Spaniel\n', 'German Shepherd\n', 'Staffordshire Bull Terrier\n', 'Cavalier King Charles Spaniel\n', 'Golden Retriever\n', 'West Highland White Terrier\n', 'Boxer\n', 'Border Terrier\n']

el ejemplo anterior también se puede hacer mediante el uso de la lista () para crear una lista fuera del objeto de archivo:

>>> f = open('dog_breeds.txt')
>>> list(f)
['Pug\n', 'Jack Russell Terrier\n', 'English Springer Spaniel\n', 'German Shepherd\n', 'Staffordshire Bull Terrier\n', 'Cavalier King Charles Spaniel\n', 'Golden Retriever\n', 'West Highland White Terrier\n', 'Boxer\n', 'Border Terrier\n']

iteración en cada línea en el archivo

una cosa común a hacer durante la lectura de un archivo es iterar sobre cada línea. Aquí está un ejemplo de cómo utilizar el método de Python .readline () para realizar esa iteración:

>>> with open('dog_breeds.txt', 'r') as reader:
>>> # Read and print the entire file line by line
>>> line = reader.readline()
>>> while line != '': # The EOF char is an empty string
>>> print(line, end='')
>>> line = reader.readline()
Pug
Jack Russell Terrier
English Springer Spaniel
German Shepherd
Staffordshire Bull Terrier
Cavalier King Charles Spaniel
Golden Retriever
West Highland White Terrier
Boxer
Border Terrier

Otra forma en que podría iterar sobre cada línea en el archivo es utilizar los .readlines Python () método del objeto archivo. Recuerde, .readlines () devuelve una lista donde cada elemento en la lista representa una línea en el archivo:

>>> with open('dog_breeds.txt', 'r') as reader:
>>> for line in reader.readlines():
>>> print(line, end='')
Pug
Jack Russell Terrier
English Springer Spaniel
German Shepherd
Staffordshire Bull Terrier
Cavalier King Charles Spaniel
Golden Retriever
West Highland White Terrier
Boxer
Border Terrier

Sin embargo, los ejemplos anteriores se puede simplificar aún más iterando sobre el propio objeto de archivo:

>>> with open('dog_breeds.txt', 'r') as reader:
>>> # Read and print the entire file line by line
>>> for line in reader:
>>> print(line, end='')
Pug
Jack Russell Terrier
English Springer Spaniel
German Shepherd
Staffordshire Bull Terrier
Cavalier King Charles Spaniel
Golden Retriever
West Highland White Terrier
Boxer
Border Terrier

Esta aproximación final es más Pythonic y puede ser más rápido y más eficiente de la memoria. Por lo tanto, se sugiere que utilice esto en su lugar.

Nota: Algunos de los ejemplos anteriores contienen print ( ‘texto’, final = »). El final = » es prevenir Python desde la adición de una nueva línea adicional para el texto que se está imprimiendo y sólo se imprime lo que se lee desde el archivo.

Ahora vamos a sumergirse en la escritura de archivos. Al igual que con la lectura de archivos, objetos de archivo tienen múltiples métodos que son útiles para escribir en un archivo:

Aquí está un ejemplo rápido de utilizar .write () y .writelines (): Trabajo

with open('dog_breeds.txt', 'r') as reader:
# Note: readlines doesn't trim the line endings
dog_breeds = reader.readlines()

with open('dog_breeds_reversed.txt', 'w') as writer:
# Alternatively you could use
# writer.writelines(reversed(dog_breeds))

# Write the dog breeds to the file in reversed order
for breed in reversed(dog_breeds):
writer.write(breed)

Con Bytes

A veces, es posible que necesite para trabajar con archivos que utilizan cadenas de bytes. Esto se hace añadiendo el carácter ‘b’ para el argumento de modo. Todos los mismos métodos para el objeto de archivo se aplican. Sin embargo, cada uno de los métodos esperan y devuelven un objeto bytes en su lugar:

>>> with open(`dog_breeds.txt`, 'rb') as reader:
>>> print(reader.readline())
b'Pug\n'

La apertura de un archivo de texto usando la opción B no es tan interesante. Digamos que tenemos esta imagen linda de un Jack Russell Terrier (jack_russell.png):

En realidad se puede abrir ese archivo en Python y examinar el contenido! Dado que el formato de archivo .png está bien definido, el encabezado del archivo es de 8 bytes rotas así:

Efectivamente, cuando se abre el archivo y lee estos bytes de forma individual, se puede ver que esto es de hecho una cabecera .png archivo:

>>> with open('jack_russell.png', 'rb') as byte_reader:
>>> print(byte_reader.read(1))
>>> print(byte_reader.read(3))
>>> print(byte_reader.read(2))
>>> print(byte_reader.read(1))
>>> print(byte_reader.read(1))
b'\x89'
b'PNG'
b'\r\n'
b'\x1a'
b'\n'

un ejemplo completo: dos2unix.py

Vamos a traer todo esto a casa y ver un ejemplo completo de cómo leer y escribir en un archivo. El siguiente es un dos2unix como herramienta que va a convertir un archivo que contiene los finales de línea de \ r \ n \ n.

Esta herramienta se divide en tres secciones principales. El primero es str2unix (), que convierte una cadena de \\ r \\ n finales de línea a \\ n. El segundo es dos2unix (), que convierte una cadena que contiene \ r \ n caracteres en \ n. dos2unix () llama str2unix (). Por último, está el bloque __main__, que se llama sólo cuando el archivo se ejecuta como un script. Piense en ello como la función principal que se encuentra en otros lenguajes de programación.

"""
A simple script and library to convert files or strings from dos like
line endings with Unix like line endings.
"""

import argparse
import os

def str2unix(input_str: str) -> str:
r"""\
Converts the string from \r\n line endings to \n

Parameters
----------
input_str
The string whose line endings will be converted

Returns
-------
The converted string
"""
r_str = input_str.replace('\r\n', '\n')
return r_str

def dos2unix(source_file: str, dest_file: str):
"""\
Coverts a file that contains Dos like line endings into Unix like

Parameters
----------
source_file
The path to the source file to be converted
dest_file
The path to the converted file for output
"""
# NOTE: Could add file existence checking and file overwriting
# protection
with open(source_file, 'r') as reader:
dos_content = reader.read()

unix_content = str2unix(dos_content)

with open(dest_file, 'w') as writer:
writer.write(unix_content)

if __name__ == "__main__":
# Create our Argument parser and set its description
parser = argparse.ArgumentParser(
description="Script that converts a DOS like file to an Unix like file",
)

# Add the arguments:
# - source_file: the source file we want to convert
# - dest_file: the destination where the output should go

# Note: the use of the argument type of argparse.FileType could
# streamline some things
parser.add_argument(
'source_file',
help='The location of the source '
)

parser.add_argument(
'--dest_file',
help='Location of dest file (default: source_file appended with `_unix`',
default=None
)

# Parse the args (argparse automatically grabs the values from
# sys.argv)
args = parser.parse_args()

s_file = args.source_file
d_file = args.dest_file

# If the destination file wasn't passed, then assume we want to
# create a new file based on the old one
if d_file is None:
file_path, file_extension = os.path.splitext(s_file)
d_file = f'{file_path}_unix{file_extension}'

dos2unix(s_file, d_file)

Consejos y trucos

Ahora que ha dominado los fundamentos de la lectura y escritura de archivos, he aquí algunos consejos y trucos para ayudar a hacer crecer sus habilidades.

__file__

El __file__ atributo es un atributo especial de módulos, similar a __name__. Es:

“la ruta del archivo desde el que se carga el módulo, si se carga desde un archivo.” (Fuente

Nota:. reiterar, devoluciones __FILE__ la trayectoria relativa a donde el guión inicial fue llamado Python Si necesita la ruta completa del sistema, puede utilizar os.getcwd () para obtener el trabajo actual directorio de su código de ejecución.

he aquí un ejemplo del mundo real. En uno de mis últimos trabajos, hice varias pruebas para un dispositivo de hardware. fue escrito Cada prueba usando un script en Python con el nombre de archivo de script de prueba utilizado como un título. Estos guiones entonces serían ejecutados y podría imprimir su estado usando el atributo especial __file__ he aquí un ejemplo de estructura de carpetas:.

project/
|
├── tests/
| ├── test_commanding.py
| ├── test_power.py
| ├── test_wireHousing.py
| └── test_leds.py
|
└── main.py

main.py correr produce lo siguiente:

>>> python main.py
testsest_commanding.py Started:
testsest_commanding.py Passed!
testsest_power.py Started:
testsest_power.py Passed!
testsest_wireHousing.py Started:
testsest_wireHousing.py Failed!
testsest_leds.py Started:
testsest_leds.py Passed!

yo era capaz de ejecutar y obtener el estado de todas mis pruebas dinámicamente a través del uso del atributo especial __file__.

Anexión a un archivo

a veces, es posible que desee añadir a un archivo o empezar a escribir al final de un archivo ya poblada. Esto se hace fácilmente mediante el uso º E ‘un’ carácter para el argumento de modo:

with open('dog_breeds.txt', 'a') as a_writer:
a_writer.write('\nBeagle')

Al examinar dog_breeds.txt de nuevo, verá que el principio del archivo no ha cambiado y ahora Beagle se añade al final del archivo:

>>> with open('dog_breeds.txt', 'r') as reader:
>>> print(reader.read())
Pug
Jack Russell Terrier
English Springer Spaniel
German Shepherd
Staffordshire Bull Terrier
Cavalier King Charles Spaniel
Golden Retriever
West Highland White Terrier
Boxer
Border Terrier
Beagle

Con Trabajo dos archivos al mismo tiempo

Hay momentos en que es posible que desee leer un archivo y escribir en otro archivo al mismo tiempo. Si utiliza el ejemplo que se muestra cuando estaban aprendiendo a escribir en un archivo, que en realidad se pueden combinar en la siguiente:

d_path = 'dog_breeds.txt'
d_r_path = 'dog_breeds_reversed.txt'
with open(d_path, 'r') as reader, open(d_r_path, 'w') as writer:
dog_breeds = reader.readlines()
writer.writelines(reversed(dog_breeds))

Creación de su propio contexto Gestor

puede llegar un momento en que necesita un control más fino del objeto de archivo colocándolo dentro de una clase personalizada. Al hacer esto, utilizando la sentencia with ya no puede ser utilizado a menos que agregue algunos métodos mágicos: __enter__ y __exit__. Mediante la adición de estos, se le han creado lo que se llama un gestor de contexto.

__enter __ () se invoca cuando se llama a la sentencia with. __exit __ () se llama al salir de la con bloque de instrucciones.

Aquí hay una plantilla que se puede utilizar para hacer su clase personalizada:

class my_file_reader():
def __init__(self, file_path):
self.__path = file_path
self.__file_object = None

def __enter__(self):
self.__file_object = open(self.__path)
return self

def __exit__(self, type, val, tb):
self.__file_object.close()

# Additional methods implemented below

Ahora que usted tiene su clase personalizada que ahora es un gestor de contexto, se puede usar de manera similar a la intemperie () incorporada:

with my_file_reader('dog_breeds.txt') as reader:
# Perform custom class operations
pass

He aquí un ejemplo bueno. Recuerde que la imagen linda de Jack Russell que teníamos? Tal vez desea abrir otros archivos .png, pero no desea analizar el archivo de cabecera cada vez. Aquí está un ejemplo de cómo hacer esto. Este ejemplo también utiliza iteradores personalizados. Si usted no está familiarizado con ellos, echa un vistazo a Python Iteradores: .png Ahora puede abrir

class PngReader():
# Every .png file contains this in the header. Use it to verify
# the file is indeed a .png.
_expected_magic = b'\x89PNG\r\n\x1a\n'

def __init__(self, file_path):
# Ensure the file has the right extension
if not file_path.endswith('.png'):
raise NameError("File must be a '.png' extension")
self.__path = file_path
self.__file_object = None

def __enter__(self):
self.__file_object = open(self.__path, 'rb')

magic = self.__file_object.read(8)
if magic != self._expected_magic:
raise TypeError("The File is not a properly formatted .png file!")

return self

def __exit__(self, type, val, tb):
self.__file_object.close()

def __iter__(self):
# This and __next__() are used to create a custom iterator
# See https://dbader.org/blog/python-iterators
return self

def __next__(self):
# Read the file in "Chunks"
# See https://en.wikipedia.org/wiki/Portable_Network_Graphics#%22Chunks%22_within_the_file

initial_data = self.__file_object.read(4)

# The file hasn't been opened or reached EOF. This means we
# can't go any further so stop the iteration by raising the
# StopIteration.
if self.__file_object is None or initial_data == b'':
raise StopIteration
else:
# Each chunk has a len, type, data (based on len) and crc
# Grab these values and return them as a tuple
chunk_len = int.from_bytes(initial_data, byteorder='big')
chunk_type = self.__file_object.read(4)
chunk_data = self.__file_object.read(chunk_len)
chunk_crc = self.__file_object.read(4)
return chunk_len, chunk_type, chunk_data, chunk_crc

Usted y correctamente analizar utilizando su gestor de contexto personalizado:

>>> with PngReader('jack_russell.png') as reader:
>>> for l, t, d, c in reader:
>>> print(f"{l:05}, {t}, {c}")
00013, b'IHDR', b'v\x121k'
00001, b'sRGB', b'\xae\xce\x1c\xe9'
00009, b'pHYs', b'(<]\x19' 00345, b'iTXt', b"L\xc2'Y" 16384, b'IDAT', b'i\x99\x0c(' 16384, b'IDAT', b'\xb3\xfa\x9a$' 16384, b'IDAT', b'\xff\xbf\xd1\n' 16384, b'IDAT', b'\xc3\x9c\xb1}' 16384, b'IDAT', b'\xe3\x02\xba\x91' 16384, b'IDAT', b'\xa0\xa99=' 16384, b'IDAT', b'\xf4\x8b.\x92' 16384, b'IDAT', b'\x17i\xfc\xde' 16384, b'IDAT', b'\x8fb\x0e\xe4' 16384, b'IDAT', b')3={' 01040, b'IDAT', b'\xd6\xb8\xc1\x9f' 00000, b'IEND', b'\xaeB`\x82'

No vuelva a inventar la serpiente

No son comunes situaciones que pueden surgir al trabajar con archivos. La mayoría de estos casos se pueden manejar utilizando otros módulos. Dos tipos de archivos comunes que pueden necesitar trabajar con son .csv y .json. real del pitón ya ha preparado una serie de grandes artículos sobre el modo de tratarlos:

  • de lectura y escritura de archivos CSV en Python
  • que trabaja con el JSON de datos en Python

Además, no están incorporados en las bibliotecas por ahí que usted se puede utilizar para ayudarle a: onda

  • : leer y archivos WAV de escritura (audio) AIFC
  • : leer y AIFF de escritura y archivos AIFC (audio)
  • sunau: lean y los archivos de escritura Sun AU
  • archivo tar: leer y escribir archivo tar archivos
  • archivo zip: trabajo con archivos ZIP
  • ConfigParser: crear fácilmente y archivos de configuración de análisis
  • xml.etree.ElementTree: crear o leer archivos basados ​​en XML
  • msilib: leer y escribir archivos de Microsoft Installer
  • plistlib: generar y analizar Mac OS X .Plist archivos

hay muchos más por ahí. Además, hay aún más herramientas tercer partido disponibles en PyPI. Entre los más populares son los siguientes: xlwings PDF conjunto de herramientas

  • ::

    • PyPDF2 leer y escribir archivos de Excel
    • Almohada: lectura de imágenes y la manipulación

    Eres un archivo de Asistente Harry!

    Usted lo hizo! Ahora ya sabe cómo trabajar con archivos con Python, incluyendo algunas técnicas avanzadas. Trabajar con archivos en Python ahora debería ser más fácil que nunca y es una gratificante sensación cuando usted comienza a hacerlo.

    En este tutorial que ha aprendido:

    • Qué es un archivo
    • Cómo abrir y cerrar archivos correctamente
    • Cómo leer y escribir archivos
    • Algunas técnicas avanzadas cuando se trabaja con archivos
    • Algunas bibliotecas de trabajo con tipos de archivo comunes

    Si tienes alguna pregunta, nos golpeó en los comentarios.

    Tome el Cuestionario: Prueba sus conocimientos con nuestro sistema interactivo “Lectura y escritura de archivos en Python” cuestionario. Al finalizar, recibirá una puntuación para que pueda controlar su progreso en el aprendizaje a través del tiempo:

    Contesta la trivia »

    Mira ahora Este tutorial tiene un vídeo relacionado curso creado por el equipo del Real Python. Mira que junto con el tutorial escrito para profundizar su comprensión: de lectura y escritura de archivos en Python

  • Deja un comentario

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *