如何搜索和替换文件中的文本?

如何使用python3搜索和替换文件中的文本?

这是我的代码:

import os
import sys
import fileinput


print ("Text to search for:")
textToSearch = input( "> " )


print ("Text to replace it with:")
textToReplace = input( "> " )


print ("File to perform Search-Replace on:")
fileToSearch  = input( "> " )
#fileToSearch = 'D:\dummy1.txt'


tempFile = open( fileToSearch, 'r+' )


for line in fileinput.input( fileToSearch ):
if textToSearch in line :
print('Match Found')
else:
print('Match Not Found!!')
tempFile.write( line.replace( textToSearch, textToReplace ) )
tempFile.close()




input( '\n\n Press Enter to exit...' )

输入文件:

hi this is abcd hi this is abcd
This is dummy text file.
This is how search and replace works abcd

当我在上面的输入文件中搜索并将“ram”替换为“abcd”时，它就像一个咒语。但当我反过来做，即替换'abcd'由'ram'，一些垃圾字符被留在最后。

将'abcd'替换为'ram'

hi this is ram hi this is ram
This is dummy text file.
This is how search and replace works rambcd
888847 次浏览
小开

你可以这样做替换

f1 = open('file1.txt', 'r')
f2 = open('file2.txt', 'w')
for line in f1:
f2.write(line.replace('old_text', 'new_text'))
f1.close()
f2.close()
小开

您的问题源于读取和写入同一个文件。不是打开fileToSearch来写，而是打开一个实际的临时文件，然后在你完成并关闭tempFile之后，使用os.rename将新文件移动到fileToSearch上。

小开

正如michaelb958所指出的，不能用不同长度的数据替换现有的部分，因为这会使其余部分不合适。我不同意其他人建议你从一个文件读到另一个文件。相反，我将把文件读入内存，修复数据，然后在单独的步骤中将其写入相同的文件。

# Read in the file
with open('file.txt', 'r') as file :
filedata = file.read()


# Replace the target string
filedata = filedata.replace('ram', 'abcd')


# Write the file out again
with open('file.txt', 'w') as file:
file.write(filedata)

除非你有一个巨大的文件要处理，它太大了，无法一次性加载到内存中，或者你担心如果在向文件写入数据的第二步过程中中断，可能会导致数据丢失。

小开

我的变种，在整个文件中一次一个词。

我把它读进了记忆。

def replace_word(infile,old_word,new_word):
if not os.path.isfile(infile):
print ("Error on replace_word, not a regular file: "+infile)
sys.exit(1)


f1=open(infile,'r').read()
f2=open(infile,'w')
m=f1.replace(old_word,new_word)
f2.write(m)
小开
最佳答案

fileinput已经支持就地编辑。在本例中，它将stdout重定向到文件:

#!/usr/bin/env python3
import fileinput


with fileinput.FileInput(filename, inplace=True, backup='.bak') as file:
for line in file:
print(line.replace(text_to_search, replacement_text), end='')
小开

正如Jack Aidley发布的和J.F. Sebastian指出的那样，这个代码是行不通的:

 # Read in the file
filedata = None
with file = open('file.txt', 'r') :
filedata = file.read()


# Replace the target string
filedata.replace('ram', 'abcd')


# Write the file out again
with file = open('file.txt', 'w') :
file.write(filedata)`

但这段代码将工作(我已经测试过了):

f = open(filein,'r')
filedata = f.read()
f.close()


newdata = filedata.replace("old data","new data")


f = open(fileout,'w')
f.write(newdata)
f.close()

使用此方法，fileein和fileout可以是同一个文件，因为Python 3.3将在打开进行写入时覆盖该文件。

小开

我是这样做的:

#!/usr/bin/env python3


import fileinput
import os


Dir = input ("Source directory: ")
os.chdir(Dir)


Filelist = os.listdir()
print('File list: ',Filelist)


NomeFile = input ("Insert file name: ")


CarOr = input ("Text to search: ")


CarNew = input ("New text: ")


with fileinput.FileInput(NomeFile, inplace=True, backup='.bak') as file:
for line in file:
print(line.replace(CarOr, CarNew), end='')


file.close ()
小开

我稍微修改了Jayram Singh的帖子，以替换每一个'!'字符转换为一个数字，我想在每个实例中增加这个数字。我想这对那些想要修改每行出现不止一次的字符并且想要迭代的人可能会有帮助。希望这能帮助到别人。PS-我在编码方面很新，所以如果我的帖子在任何方面都不合适，我很抱歉，但这对我来说是有效的。

f1 = open('file1.txt', 'r')
f2 = open('file2.txt', 'w')
n = 1


# if word=='!'replace w/ [n] & increment n; else append same word to
# file2


for line in f1:
for word in line:
if word == '!':
f2.write(word.replace('!', f'[{n}]'))
n += 1
else:
f2.write(word)
f1.close()
f2.close()
小开 
def word_replace(filename,old,new):
c=0
with open(filename,'r+',encoding ='utf-8') as f:
a=f.read()
b=a.split()
for i in range(0,len(b)):
if b[i]==old:
c=c+1
old=old.center(len(old)+2)
new=new.center(len(new)+2)
d=a.replace(old,new,c)
f.truncate(0)
f.seek(0)
f.write(d)
print('All words have been replaced!!!')
小开 
def findReplace(find, replace):


import os


src = os.path.join(os.getcwd(), os.pardir)


for path, dirs, files in os.walk(os.path.abspath(src)):


for name in files:


if name.endswith('.py'):


filepath = os.path.join(path, name)


with open(filepath) as f:


s = f.read()


s = s.replace(find, replace)


with open(filepath, "w") as f:


f.write(s)
小开

你也可以使用pathlib。

from pathlib2 import Path
path = Path(file_to_search)
text = path.read_text()
text = text.replace(text_to_search, replacement_text)
path.write_text(text)
小开

使用单个With块，您可以搜索和替换您的文本:

with open('file.txt','r+') as f:
filedata = f.read()
filedata = filedata.replace('abc','xyz')
f.truncate(0)
f.write(filedata)
小开

(pip install python-util)

from pyutil import filereplace


filereplace("somefile.txt","abcd","ram")

将替换所有出现的"abcd"与“ram"。
该函数还通过指定regex=True

来支持regex 
from pyutil import filereplace


filereplace("somefile.txt","\\w+","ram",regex=True)

免责声明:我是作者(https://github.com/MisterL2/python-util)

小开

像这样:

def find_and_replace(file, word, replacement):
with open(file, 'r+') as f:
text = f.read()
f.write(text.replace(word, replacement))
小开

晚回答，但这是我用来在文本文件中查找和替换的:

with open("test.txt") as r:
text = r.read().replace("THIS", "THAT")
with open("test.txt", "w") as w:
w.write(text)

< a href = " https://trinket。io / python3 b1d31242f1 noreferrer“rel = >演示< / >

小开
除了已经提到的答案，这里是为什么你在结尾有一些随机字符的解释:
您正在以r+模式打开文件，而不是w模式。关键的区别是w模式在你打开文件时立即清除文件的内容，而r+则不会。
这意味着如果您的文件内容是“123456789”;然后你写下"www"对它，你得到"www456789"它用新的输入覆盖字符，但保留任何剩余的输入。
你可以通过使用truncate(<startPosition>)来清除文件内容的一部分，但是你最好先将更新后的文件内容保存为一个字符串，然后执行truncate(0)并一次性写入。
或者你可以使用我的图书馆:D

小开

我已经把这个作为一个课程的练习:打开文件，找到并替换字符串，并写入一个新文件。

class Letter:


def __init__(self):


with open("./Input/Names/invited_names.txt", "r") as file:
# read the list of names
list_names = [line.rstrip() for line in file]
with open("./Input/Letters/starting_letter.docx", "r") as f:
# read letter
file_source = f.read()
for name in list_names:
with open(f"./Output/ReadyToSend/LetterTo{name}.docx", "w") as f:
# replace [name] with name of the list in the file
replace_string = file_source.replace('[name]', name)
# write to a new file
f.write(replace_string)




brief = Letter()
小开

我也有同样的问题。问题是，当你在变量中加载一个.txt时，你把它当作一个字符串数组使用，而它是一个字符数组。

swapString = []
with open(filepath) as f:
s = f.read()
for each in s:
swapString.append(str(each).replace('this','that'))
s = swapString
print(s)
小开

我试过用readline代替read

with open('dummy.txt','r') as file:
list = file.readlines()
print(f'before removal {list}')
for i in list[:]:
list.remove(i)


print(f'After removal {list}')
with open('dummy.txt','w+') as f:
for i in list:
f.write(i)
小开

这个答案适合我。以读模式打开文件。以字符串格式读取文件。替换文本。关闭文件。再次以写模式打开文件。最后，将替换后的文本写入相同的文件。

    with open("file_name", "r+") as text_file:
texts = text_file.read()
texts = texts.replace("to_replace", "replace_string")
with open(file_name, "w") as text_file:
text_file.write(texts)
except FileNotFoundError as f:
print("Could not find the file you are trying to read.")
小开

你可以在python中使用sed、awk或grep(有一些限制)。这里有一个非常简单的例子。它在文件中把香蕉变成香蕉牙膏。你可以编辑和使用它。(我测试过了…注意:如果你在Windows下测试，你应该安装"命令并先设置路径)

import os
file="a.txt"
oldtext="Banana"
newtext=" BananaToothpaste"
os.system('sed -i "s/{}/{}/g" {}'.format(oldtext,newtext,file))
#print(f'sed -i "s/{oldtext}/{newtext}/g" {file}')
print('This command was applied:  sed -i "s/{}/{}/g" {}'.format(oldtext,newtext,file))

如果你想直接在文件上看到结果，请使用:"type"对于windows/ "cat"linux:

####FOR WINDOWS:
os.popen("type " + file).read()
####FOR LINUX:
os.popen("cat " + file).read()
小开

使用re.subn可以对替换过程进行更多的控制，例如将单词分隔为两行，区分大小写的匹配。此外，它返回匹配的数量，如果没有找到字符串，可以使用这些匹配来避免浪费资源。

import re


file = # path to file


# they can be also raw string and regex
textToSearch = r'Ha.*O' # here an example with a regex
textToReplace = 'hallo'


# read and replace
with open(file, 'r') as fd:
# sample case-insensitive find-and-replace
text, counter = re.subn(textToSearch, textToReplace, fd.read(), re.I)


# check if there is at least a  match
if counter > 0:
# edit the file
with open(file, 'w') as fd:
fd.write(text)


# summary result
print(f'{counter} occurence of "{textToSearch}" were replaced with "{textToReplace}".')

一些正则表达式:

  • 添加re.I标志，即re.IGNORECASE的缩写形式，用于不区分大小写的匹配
  • 对于多行替换re.subn(r'\n*'.join(textToSearch), textToReplace, fd.read())，取决于数据也'\n{,1}'。注意，在这种情况下textToSearch必须是一个纯字符串，而不是正则表达式!

提交答案