pitón base del archivo de leer y escribir

Lectura y escritura de archivos

Es el archivo más común leer y operaciones de escritura IO, pitón funciones integradas para leer y escribir archivos, uso, y C son compatibles.

Antes de leer y escribir archivos, tenemos que mirar, leer y archivos de escritura en las funciones de disco son proporcionados por el sistema operativo, el sistema operativo moderno no permitir el funcionamiento normal del programa directamente en el disco, el archivo se leer y escribir pide al sistema operativo para abrir un objeto de archivo (descripción del archivo), y luego, la interfaz proporcionada por el sistema operativo lee los datos (archivos de lectura) de este objeto de archivo, o para escribir datos a la (archivo de escritura) objeto de archivo

al leer el archivo

Para abrir un archivo con el modo de leer un objeto de archivo, utilizando Python incorporada función open (), pasando el nombre del archivo y los identificadores:

>>> f = open('/user/demo/test.txt','r')

Identificador 'r' para lectura, para que podamos abrir correctamente un archivo

Si no existe el archivo, la función open () generará un error IOError, y le dará el código de error y el mensaje detallado, a decir el archivo no existe.

>>> f=open('/Users/michael/notfound.txt', 'r')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: '/Users/michael/notfound.txt'

Si el archivo se abre correctamente, entonces llamada de lectura () método puede leer el contenido de archivos a la vez, pitón leer los contenidos en la memoria, el objeto se representa por un str

>>> f.read()
'hello world!'

El paso final llama al método close () para cerrar el archivo, el archivo debe ser cerrado después de su uso, ya que el objeto de archivo ocupará los recursos del sistema operativo y el sistema operativo al mismo tiempo el número de archivos que pueden ser abiertos está limitado.

>>> f.close()

Dado que el archivo de lectura y escritura son propensos a producir IOError, una vez que el error, volver a f.close () no se llamará, por lo tanto, con el fin de garantizar que el archivo de ejecución de error se puede corregir cerrar el archivo, podemos utilizar intento ... por fin hacerse realidad.

try:
    f = open('/path/demo/file','r')
    print(f.read())
finally:
    if f:
        f.close()  

Pero de vez realistas en demasiado engorroso, por lo que, con la introducción de la declaración de forma automática ayudarnos a llamar al método close ():

with open('/path/demo/file', 'r')  as f:
    print(f.read())

Esta es la parte delantera de la oportunidad ... finalmente es el mismo, pero el código es más concisa, y no tiene que llamar al método f.close ().

Nota: El uso de la lectura () leerá el contenido completo del archivo una vez, si el archivo es muy grande, por ejemplo, hay 5G, entonces su memoria a la explosión, por lo que es seguro, podemos repetidamente llamada de lectura (tamaño) método, cada contenido de lectura hasta bytes de tamaño, llamadas adicionales del readline () puede leer cada línea de texto en los readlines call () para leer todo el contenido de una sola vez, la línea de retorno de prensa Lista, por lo tanto, necesario decidir cómo llamar.

Si el archivo es pequeño, leer () lee el momento más conveniente, si no se puede determinar el tamaño del archivo, llamando repetidamente lectura (tamaño) más seguros, si el archivo de configuración, readlines llamada () el más conveniente

for line in f.readlines():
    #把末尾的'\n'删掉
    print(line.strip())

archivo binario

Hablando frente al archivo de texto por defecto es leer, y es UTF-8 archivos de texto codificados, para leer archivos binarios, tales como imágenes, vídeo, etc., se abrió con el modo de archivo 'rb' puede ser:

>>> f = open('/users/demo/test.jpg',"rb")
>>> f.read()
b'\xff\xd8\xff\xe1\x00\x18Exif\x00\x00...' # 十六进制表示的字节

codificación de caracteres

Para leer 8 UTF-archivos de texto no codificadas, es necesario abrir la función () hacer pasar el parámetro de codificación, por ejemplo, leer GBK archivos codificados:

>>> f = open('/user/demo/gbk.txt','r',encoding = 'gbk')
>>> f.read()
'测试'

Algunos no estándar encuentros de codificación de un archivo, puede encontrar UnicodeDecodeError, ya que en el archivo de texto puede ser mezclado con un poco de la codificación de caracteres ilegal, en cuyo caso, la función open () también recibe un error de parámetro, indique si se encuentra con la codificación cómo hacer frente a después del error, la forma más fácil es simplemente ignorar.

>>> f = open('/users/demo/gbk.txt','r',encoding = 'gbk',errors = 'ignore')

Escribir archivo

archivos de escritura y lectura de documentos son los mismos, la única diferencia es la llamada a la función open (), el identificador de entrada 'w' o 'wb' representa un documento escrito o escribir archivos binarios:

>>> f = open("/users/demo/test.txt",'w')
>>> f.write('hello, world!')
>>> f.close()

Puede llama repetidamente a escribir () para escribir en el fichero, pero asegúrese de f.close llamada () para cerrar el archivo.

Cuando escribimos un archivo, el sistema operativo a menudo do datos no inmediatamente escribir en el disco, pero en caché en la memoria, el método lentamente por escrito, solamente llame a close () tiempo libre y luego, el sistema operativo no es sólo para garantizar la todos los datos escritos se escribe en el disco, olvidar las consecuencias de llamar a close () es parte de los datos sólo se puede escribir en el disco, los restantes perdieron, por lo que su uso con un seguro o una declaración de:

with open('/users/demo/test.txt', 'w') as f:
    f.write('hello, world')

función Para escribir un archivo de texto codificado específico, para abrir () hacer pasar el parámetro de codificación, la cadena se convierte automáticamente en el código especificado.

Al escribir archivos en el modo 'w', si el archivo ya existe, de sobreescritura (escribe una nueva entrada equivalente a eliminar el archivo), si queremos añadir al final del archivo de cómo hacerlo? Puede pasar 'a' en modalidad de apertura escribir.

with open('/users/demo/test.txt', 'a') as f:
    f.write('hello, world')

StringIO

En muchos casos, los datos de lectura y escritura no es necesariamente un archivo, también puede leer y escribir en la memoria.

stirngIO su nombre indica es para leer y escribir en la memoria str

Str debe escribir StringIO, tenemos que crear un StringIO, entonces, como un archivo se puede escribir:

from io import StringIO
f = StringIO()
f.write("hello")
f.write("   ")
f.write('world')
#获取写入后的str
print(f.getvalue())

Para leer StringIO, se puede utilizar un str inicialización StringIO, entonces, como leer el mismo documento dice lo siguiente:

from io import StringIO
f = StringIO("Hello\nHi\nGoodBye!")
while True:
    s = f.readline()
    if s == '':
        break
    print(s.trip())
#
Hello!
Hi!
Goodbye!

BytesIO

StringIO operación sólo puede ser str, si se está trabajando con datos binarios, es necesario utilizar BytesIO.

BytesIO lograr la lectura y escritura en bytes de memoria, creamos un BytesIO, y luego escribe algunos bytes:

from io import BytesIO
f = BytesIO()
f.write("中文".encode('utf-8'))
print(f.getvalue())

Nota: Write no str, pero después de bytes UTF-8 codificados

StringIO y similares, se pueden inicializar con un BytesIO bytes, y luego, como leer el mismo documento se lee:

from io import BytesIO
f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
f.read()
b'\xe4\xb8\xad\xe6\x96\x87'

El método de funcionamiento de StringIO y BytesIO str y bytes en la memoria, por lo que los archivos de lectura y escritura que tiene una interfaz consistente.

serialización

El programa se está ejecutando, todas las variables están en la memoria, tales como la definición de un diccionario

dict1 = {name:"lili",age:18}

Cuando puse el nombre aquí para modificar, cambiar "leilei", pero una vez que el final del programa, la memoria de variables ocupado por el sistema operativo se recuperó por completo, si no para modificar el nombre guardado en el disco, el siguiente nombre y la inicialización es "Lili"

Aquí podemos estar almacenada o transmitida en la variable de proceso de la memoria se llama la serialización en Python llamada cosecha, después de la serialización, podemos poner el contenido de la secuencia escrita en el disco o transmitida a través de la red a otras máquinas. A la inversa, volver a leer de los contenidos de la secuencia variable de la memoria de destino se refiere deserializar, es decir Desgrapado.

módulo de Python salmuera proporcionado para implementar la serialización.

import pickle
d = dict({name:"lili",age:18})
#pickle.dumps()方法把任意对象序列化成一个bytes，然后就可以把bytes写入文件
print(pickle.dumps(d))

#把序列化后的对象写入文件
f = open("dump.txt",'wb')
#参数一：要写入的对象， 参数二：写入文件的对象
pickle.dumps(d,f)
f.close()

#从文件中读取序列化后的对象
f2 = open("dump.txt","rb")
#pickle.load()反序列化对象
d = pickle.load(f)
f.close()

Nota: Pitón de la salmuera se puede utilizar solamente, y diferentes versiones de Python no son compatibles entre sí, por lo tanto, sólo se puede mantener algunos datos importantes con salmuera, así que si no deserializar éxito no importará.

JSON

Si tenemos que pasar objetos entre diferentes lenguajes de programación, entonces tenemos que la secuencia diana en un formato estandarizado, como XML, pero un mejor enfoque consiste en JSON, JSON demostrarlo, ya que es una cadena que puede ser leído por todos los idiomas , también conveniente para la transmisión de disco o red, JSON no sólo el modo estándar, y la velocidad es más rápido que el XML, también se puede leer en la web, es muy conveniente.

tipo de JSON	tipo de Python
{}	dict
[]	lista
"cuerda"	str
1234.56	int o float
verdadero Falso	Verdadero Falso
nulo	Ninguna

dict del pitón objetos en un JSON

import json

d = dict({name:"lili",age:19})
#使用json.dumps()方法返回一个str，这个str就是标准的json
print(json.dumps(d))

#把json反序列化为一个python对象
jsonStr = '{name:"lili",age:19}'
print(json.loads(jsonStr))

Una clase para serializar objetos en JSON

import json

class Student(object):
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

#将student对象转换为dict        
def student2dict(std):
    return {
        'name': std.name,
        'age': std.age,
        'score': std.score
    }        
s = Student('Bob', 20, 88)
#参数一：要传入的对象  参数二：将对象转为dict的函数
json.dumps(s,default=student2dict)

#将dict转为对象
def dict2student(d):
    return Strdent(d['name'],d['age'],d['score'])
jsonStr ='{"age": 20, "score": 88, "name": "Bob"}'
#json反序列化为一个对象
#参数一：json字符串，参数二：dict转为对象的函数
print(json.loads(jsonStr,object_hook=dict2student))

de archivos de lectura y escritura csv

csv lectura

propio archivo CSV es un archivo de texto plano, este formato de archivo se utiliza a menudo como el formato de intercambio de datos entre diferentes programas.

demostración:

Requisitos: leer el archivo 001.scv

Nota: Se puede imprimir directamente, a continuación, definir la lista

import csv

def readCsv(path):
    #列表
    infoList = []
    #以只读的形式打开文件
    with open(path, 'r')  as f:
        #读取文件的内容
        allFileInfo = csv.reader(f)
        #将获取到的内容逐行追加到列表中
        for row in allFileInfo:
            infoList.append(row)
    return infoList
path = r"C:\Users\xlg\Desktop\001.csv"
info = readCsv(path)

Escribir archivo csv

demostración:

Requisitos: escritura al archivo 002.csv

import csv

#以写的方式打开文件
def writeCsv(path,data)
    with open(path,'w')  as f:
        writer = csv.writer(f)
        for rowData in data:
            print("rowData =", rowData)
            #按行写入
            writer.writerow(rowData)
path = r"C:\Users\xlg\Desktop\002.csv"
writeCsv(path,[[1,2,3],[4,5,6],[7,8,9]])        

Lectura de archivos PDF

pip es una herramienta de instalación y gestión de paquetes Python

Antes de que los programas de código, pdf primera instalación de todas las herramientas y asociados

. A Introduzca el siguiente comando cmd: Lista de pepita [acción: Lista de todas las herramientas montadas PIP]

. B instalar pdfminer3k, continúe entrando el siguiente comando: pip instalar pdfminer3k

c. Código de demostración

#导入系统库
import sys
import importlib
#对importlib做处理,让其加载sys
importlib.reload(sys)

from pdfminer.pdfparser import PDFParser,pdFDocument
from pdfminer.pdfinterp import PDFResourceManager,PDFPageInterpreter#解释器
from pdfminer.converter import PDFPageAggregator#转换器
from pdfminer.layout import LTTextBoxHorizontal,LAParams #布局

from pdfminer.pdfinterp import PDFTextExtractionNotAllowed #是否允许pdf和text转换

#将path文件中的内容读取到topath文件中
def readPDF(path, toPath):
    #以二进制的形式打开pdf文件
    f = open(path, 'rb')
    #创建一个pdf文档分析器
    parser = PDFParser(f)
    #创建pdf文档
    pdfFile = PDFDocument()
    #获取连接分析器
    parser.set_document(pdfFile)
    #获取文档对象
    pdfFile.initialize()
    #检测文档是否提供txt转换
    if not pdfFile.is_extractable:
        #不允许转换
        raise PDFTextExtractionNotAllowed
    else:
        #解析数据
        #数据管理器
        manger = PDFResourceManger()
        #创建一个PDF设备对象
        laparams = PDFPageAggregator(manager,laparams=laparams)
        #解释器对象
        interpreter = PDFPageInterpreter(manger,device)
        #开始循环处理,每次处理一页
        for page in pdfFile.get_pages():
            interpreter.process_page(page)
            layout = device.get_result()
            for x in layout:
                if(isinstance(x, LTTextBoxHorizontal)):
                    with open(toPath, 'a') as f:
                        str = x.get_text()
                        #print(str)
                        f.writer(str + "\n")
path = r"C:\Users\xlg\Desktop\001.pdf"
toPath = r"C:\Users\xlg\Desktop\001.pdf"
readPDF(path,toPath)

Control de errores

El programa se está ejecutando, si se produce un error, se puede acordar de antemano un código de error, por lo que se puede saber si hay mal, y la causa del error, llamar al sistema operativo, el retorno es códigos de error muy comunes, como abrir un archivo función abierta, devuelve un descriptor de archivo en el éxito [es un entero], devuelve el error -1, pero con el código de error indica si el error es muy incómodo, ya que la función en sí debería volver a los resultados normales y código de error mezclados entre sí, por lo que la llamada a aquellos que utilizan una gran cantidad de código para determinar si el error del programa.

Por lo tanto, en el alto nivel de idiomas se construyen generalmente en un intento ... excepto ... finalmente ... mecanismo de control de errores, pitón no es una excepción.

#try的机制
try:
    print("try...")
    r = 10/0
    print('result', r)
except ZeroDivisionError as e:
    print("except:", e)
finally:
    print("finally...")
print("END")   

Cuando pensamos en una parte del código puede estar equivocado, se puede tratar de ejecutar este código, si se ejecuta mal, entonces el siguiente código no va a continuar, pero el código de manejo de errores para saltar directamente a esa aplicación, excepto bloque de instrucciones de Fin después excepto, si hay bloques finally se ejecuta el bloque finally, hasta ahora, ha terminado.

Se puede ver en la entrada, cuando se produce un error, se imprimen las declaraciones posteriores ( 'resultado', r) no se realiza, ya que la excepción de la captura de la ZeroDivisionError, se lleva a cabo por lo tanto, es finalmente ejecutado el último comunicado.

Hay muchos tipos de errores debe, si un tipo diferente de error se produce, debe ser manejado por una diferente, excepto bloque de instrucciones, pero en realidad el error Python es la clase, todos los tipos de error se heredan de BaseException, por lo que su uso excepto

Tenga en cuenta que, no solamente capturar este tipo de error, también otras subsecciones también atrapados

Uso oportunidad ... excepto para los errores de captura y una gran ventaja es que se puede llamar a través de múltiples capas. En otras palabras, no tenemos a todos los lugares que podía salir mal salió mal captura, para capturar el nivel justo de error en el mismo, de esta manera, lo que reduce en gran medida la oportunidad ... ... excepto por último problema.

Pila de llamadas

Si no se detecta el error, habría sido arrojado, finalmente capturado intérprete de Python, se imprime un mensaje de error y el programa se cierra.

def foo(s):
    return 10/int(s)

def bar(s):
    return foo(s)*2

def main():
    bar('0')
main()

Que va mal, hay que analizar la información de error pila de llamadas, a fin de localizar el error

error de grabación

Si no detectar errores, natural permite intérprete de Python para imprimir la pila de errores, pero el programa también ha terminado, ya que podemos detectar errores, puede enderezar la pila equivocada de imprimir, a continuación, analizar la causa del error, al tiempo que permite que el programa continúe la ejecución .

pitón construido en el módulo de registro puede ser muy fácil de grabar el mensaje de error:

import logging

def foo(s)：
    return 10/int(s)
def bar(s)
    return foo(s)*2

def mian():
    try:
        bar('0')
    except Exception as e:
        logging.except(e)
main()
print("END")       

Lo mismo es malo, pero el programa continuará la impresión de la información, y la salida normal

Lanza un error

Debido a que el error es de clase, la captura de un error es capturar una instancia de la clase, por lo que los errores no se producen de la nada, pero intencionalmente creados y lanzados, pyhton funciones incorporadas lanzará muchos tipos de errores, escribir nuestra propia la función también puede lanzar un error.

Si usted quiere lanzar un error, en primer lugar es necesario, puede definir una clase de mal, elegir una buena herencia, luego tirar una declaración de error instancia aumento.

class  FooError(valueError)：
    pass
def foo(s)：
    n = int(s)
    if n == 0:
        raise FooError("invalid value :%s"%s)
    return 10/n
foo('0')

Sólo definir nuestros propios tipos de errores cuando sea necesario, si se puede elegir pitón integrado existente en los tipos de error, intente utilizar el tipo equivocado de una función de pitón.