Cet article vous présente principalement les opérations sur les fichiers Python et les simples copies et sauvegardes. J'espère qu'il pourra vous aider.

1. fonction d'ouverture
Tout en python est un objet, donc le processus normal pour ouvrir un fichier est
Sélectionner le fichier - ouvrir le fichier - modifier, copier. , suppression et autres opérations - Pour fermer le fichier
, mettez-le en python et utilisez le code :
f = open(file, mode='r', buffering=None, encoding=None, error=None, newline =Aucun, closefd=True) :
f.close()
où file est le chemin absolu du fichier plus le nom du fichier, mode est la méthode de lecture du fichier, la valeur par défaut est r, qui est en lecture seule mode, et le mode
facultatif suivant est interprété dans le code source comme

‘r’       open for reading (default) 
‘w’       open for writing, truncating the file first 
‘x’       create a new file and open it for writing 
‘a’       open for writing, appending to the end of the file if it exists 
‘b’       binary mode 
‘t’       text mode (default) 
‘+’       open a disk file for updating (reading and writing) 
‘U’       universal newline mode (deprecated)

Copier après la connexion

Il est recommandé de lire le code source : la traduction est :
r Ouvrez le fichier en mode lecture seule. Le pointeur de fichier sera placé au début du fichier. C'est le mode par défaut.
rb Ouvre un fichier au format binaire en lecture uniquement. Le pointeur de fichier sera placé au début du fichier. C'est le mode par défaut.
r+ Ouvrir un fichier en lecture et en écriture. Le pointeur de fichier sera placé au début du fichier.
rb+ ouvre un fichier au format binaire en lecture et en écriture. Le pointeur de fichier sera placé au début du fichier.
w Ouvrir un fichier en écriture uniquement. Si le fichier existe déjà, il est écrasé. Si le fichier n'existe pas, créez un nouveau fichier.
wb Ouvre un fichier au format binaire en écriture uniquement. Si le fichier existe déjà, il est écrasé. Si le fichier n'existe pas, créez un nouveau fichier.
w+ Ouvrir un fichier en lecture et en écriture. Si le fichier existe déjà, il est écrasé. Si le fichier n'existe pas, créez un nouveau fichier.
wb+ ouvre un fichier au format binaire en lecture et en écriture. Si le fichier existe déjà, il est écrasé. Si le fichier n'existe pas, créez un nouveau fichier.
a Ouvrez un fichier à ajouter. Si le fichier existe déjà, le pointeur de fichier sera placé à la fin du fichier. En d’autres termes, le nouveau contenu sera écrit après le contenu existant. Si le fichier n'existe pas, créez un nouveau fichier en écriture.
ab Ouvre un fichier au format binaire pour l'ajouter. Si le fichier existe déjà, le pointeur de fichier sera placé à la fin du fichier. En d’autres termes, le nouveau contenu sera écrit après le contenu existant. Si le fichier n'existe pas, créez un nouveau fichier en écriture.
a+ Ouvrir un fichier en lecture et en écriture. Si le fichier existe déjà, le pointeur de fichier sera placé à la fin du fichier. Le fichier sera ouvert en mode ajout. Si le fichier n'existe pas, un nouveau fichier est créé pour la lecture et l'écriture.
ab+ ouvre un fichier au format binaire pour l'ajouter. Si le fichier existe déjà, le pointeur de fichier sera placé à la fin du fichier. Si le fichier n'existe pas, un nouveau fichier est créé pour la lecture et l'écriture.
Ici, nous devons appeler la méthode f.close à chaque fois que nous ouvrons le fichier. C'est gênant et facile à oublier. Ici, nous utilisons with pour l'optimiser :
with open("E:githubprojectSource-codebasisfiletest.txt. ", mode='r') comme f :
pass
ici f équivaut à ouvrir le fichier, mais le fichier n'est pas lu pour le moment, c'est-à-dire que le fichier n'est pas placé dans la mémoire f a de nombreuses méthodes intégrées, la plus couramment utilisée est f. .write()
ici Nous utilisons fwrite pour copier des fichiers :
avec open("E:githubprojectSource-codebasisfiletest.txt", mode='r') as f:
contenu = f.read()
avec open("E:githubprojectSource-codebasisfiletest_bak.txt", mode='w') comme f_bak :
f_bak.write(contents)
Mais cette méthode doit être écrite à chaque fois, nous utilisons donc une fonction pour encapsuler le nom du fichier
def cp(path):
. avec open(path, 'r') comme f :
Données = f.read()
Filename = path[0:path.rindex(“.”)] # Obtenez la chaîne précédente (c'est-à-dire le nom du fichier) via la méthode rindex
ext = path[path.rindex(“.”):] # Obtenez la chaîne après (c'est-à-dire le suffixe du fichier) via la méthode rindex
. Avec open("%s_bak%s" % (filename, ext), 'w') comme f_bak : # Créez un nouveau fichier nommé _bak pour l'ouvrir et l'utiliser
f_bak.write(data)

path = « E:githubprojectSource-codebasisfiletest.txt »
path = path.replace(« », « / ») # Convertir le contenu contenu dans la chaîne Pour éviter les erreurs de conversion de caractères spéciaux pour /

path = '/'.join(path.split('')) #Similaire à la méthode ci-dessus, mais les caractères spéciaux ne peuvent pas encore être convertis...

cp(path)
Le problème du nom de fichier et du chemin combinés en caractères spéciaux dans Windows n'a pas encore été résolu
Lorsque nous appelons la méthode read, le fichier sera écrit dans la mémoire, mais si nous je veux copier un gros Que dois-je faire si le fichier a 10 Go, par exemple ?
L'opération de fichier Python a un pointeur, c'est-à-dire que lorsque nous lisons quelque part, le pointeur pointe vers l'endroit où nous lisons, et quand nous lisons() lorsque read(100), le pointeur pointe vers 100, et la lecture suivante lira à partir d'ici f.seek(0, 0) renverra le pointeur à la position initiale. Nous pouvons utiliser le pointeur pour copier en grand. fichiers en une seule lecture :

def cp(path): 
    filename = path[0:path.rindex(“.”)]  # 通过rindex方法取得.之前的字符串(即文件名) 
    ext = path[path.rindex(“.”):]  # 通过rindex方法取得.之后的字符串(即文件后缀) 
    with open(path, ‘r’) as f, open(“%s_bak%s” % (filename, ext), ‘a’) as f_bak: 
        while True: 
            data = f.read(1024) 
            print(data) 
            f_bak.write(data) 
            if len(data) == 0: 
                break
path = “E:\githubproject\Source-code\basis\file\test.txt” path = path.replace(“\”, “/”)  # 将字符串中含\的转换为/,避免出现特殊字符转换错误的问题

Copier après la connexion

path = ‘/’.join(path.split(‘\’)) #与上方法类似,但是还无法转换特殊字符…

cp(path)

这篇文章主要介绍了python操作文件,以及简单的复制备份.
1.open函数
python中一切皆对象,所以正常我们打开一个文件的过程是
1.选中文件-打开文件-编辑,复制,删除等操作-关闭文件
放到python中用代码实现就是:
f = open(file, mode=’r’, buffering=None, encoding=None, errors=None, newline=None, closefd=True):
f.close()
其中file是文件的绝对路径加文件名,mode是文件读取方式,默认为r即只读方式,后面的选填
mode在源码的解释为

‘r’       open for reading (default) 
‘w’       open for writing, truncating the file first 
‘x’       create a new file and open it for writing 
‘a’       open for writing, appending to the end of the file if it exists 
‘b’       binary mode 
‘t’       text mode (default) 
‘+’       open a disk file for updating (reading and writing) 
‘U’       universal newline mode (deprecated)

Copier après la connexion

建议大家看源码:翻译过来就是:
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
这里我们每次打开file都要调用f.close方法比较麻烦也容易忘,这里用with优化一下:
with open(“E:\githubproject\Source-code\basis\file\test.txt”, mode=’r’) as f:
pass
这里f就相当于打开了文件,但是此时并没有读取文件,即没有把文件放到内存中,f有很多内置方法,比较常用的是f.write()
这里我们使用fwrite来实现文件的复制:

with open(“E:\githubproject\Source-code\basis\file\test.txt”, mode=’r’) as f: 
    contents = f.read() 
    with open(“E:\githubproject\Source-code\basis\file\test_bak.txt”, mode=’w’) as f_bak: 
        f_bak.write(contents) 但是这个方法每次都要写,所以我们用个函数把文件名封装进进去. def cp(path): 
    with open(path, ‘r’) as f: 
        data = f.read() 
        filename = path[0:path.rindex(“.”)]  # 通过rindex方法取得.之前的字符串(即文件名) 
        ext = path[path.rindex(“.”):]  # 通过rindex方法取得.之后的字符串(即文件后缀) 
        with open(“%s_bak%s” % (filename, ext), ‘w’) as f_bak:  # 新建文件名_bak的文件打开并操作 
            f_bak.write(data)
path = “E:\githubproject\Source-code\basis\file\test.txt” path = path.replace(“\”, “/”)  # 将字符串中含\的转换为/,避免出现特殊字符转换错误的问题

Copier après la connexion

path = ‘/’.join(path.split(‘\’)) #与上方法类似,但是还无法转换特殊字符…

cp(path)
目前还没解决windows中文件名加路径组合成了特殊字符的问题
我们调用read方法的时候会将文件写入内存,但是如果我们要复制一个很大的文件,比如有10个G的时候怎么办呢,
python文件操作有个指针的说法,即当我们read到某处的时候,指针就会指到read的地方,当我们read()的时候,文件就指向了末尾,当read(100),指针即指向100,下次read再从此处读取,f.seek(0, 0)即将指针回到初始位置,我们可以利用指针来多次读取实现大文件的复制:

def cp(path): 
    filename = path[0:path.rindex(“.”)]  # 通过rindex方法取得.之前的字符串(即文件名) 
    ext = path[path.rindex(“.”):]  # 通过rindex方法取得.之后的字符串(即文件后缀) 
    with open(path, ‘r’) as f, open(“%s_bak%s” % (filename, ext), ‘a’) as f_bak: 
        while True: 
            data = f.read(1024) 
            print(data) 
            f_bak.write(data) 
            if len(data) == 0: 
                break
path = “E:\githubproject\Source-code\basis\file\test.txt” path = path.replace(“\”, “/”)  # 将字符串中含\的转换为/,避免出现特殊字符转换错误的问题

Copier après la connexion