可以定义几个函数，把处理数据的逻辑放在函数中，然后再定义线程去调用函数

from threading import Thread



t1 = Thread(target=函数1)#这里只写函数名，不要带括号

t1.start()



t2 = Thread(target=函数2)

t2.start()

Quote: 引用 1 楼 一笑程序猴 的回复:

可以定义几个函数，把处理数据的逻辑放在函数中，然后再定义线程去调用函数

from threading import Thread



t1 = Thread(target=函数1)#这里只写函数名，不要带括号

t1.start()



t2 = Thread(target=函数2)

t2.start()

先谢谢大佬，主要不是很明白他这个线程是直接写在我的这个代码的前边 还是说得另外再写一个，

Quote: 引用 3 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 1 楼 一笑程序猴 的回复:

可以定义几个函数，把处理数据的逻辑放在函数中，然后再定义线程去调用函数

from threading import Thread



t1 = Thread(target=函数1)#这里只写函数名，不要带括号

t1.start()



t2 = Thread(target=函数2)

t2.start()

先谢谢大佬，主要不是很明白他这个线程是直接写在我的这个代码的前边 还是说得另外再写一个，

首先要理解一下线程的概念，多线程可以同时异步执行，所以可以让你的程序处理逻辑变快，但前提是让不同的线程同时去处理不同的互不关联的逻辑。
像你上面描述的数据量很大，如果是有很多个单独的文件确实可以用多线程去处理，你可以为每个文件的读取逻辑单独写个函数，然后再去定义多个线程去执行函数。或者把某几个文件的读取放在同一个函数中用线程去执行，这样就可以多个文件同时处理了，速度也会大大加快，至于线程写在哪都无所谓。
还有一种情况就是如果你只有一个文件，而文件里的数据量很大有几千或几万行，那么这种情况是不适合用线程的，因为不管怎么说你都要从头读到尾去处理的。
但是看你上面的描述应该是第二种情况，是在你的文件里有大量的数据要去处理的吧，如果是这样的话，不太适合用线程的。如果非要用线程的话，可以把文件拆分成多个文件，然后再去写多个线程去处理。
写法可以参考如下：

import re 

from threading import Thread

  

def process_file():

    fo = open("1.txt", "r"); 

    co = open("2.txt", "r");

    colines = co.readlines();

  

    for line in fo.readlines():

        line = line.strip();

        matchObj = re.search( line, "%s" %  colines, re.M | re.I);

 

        if matchObj:

            print (line);

  

 

    fo.close();

    co.close();



t1 = Thread(target=process_file)#这里只写函数名，不要带括号

t1.start()

Quote: 引用 4 楼 一笑程序猴 的回复:

Quote: 引用 3 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 1 楼 一笑程序猴 的回复:

可以定义几个函数，把处理数据的逻辑放在函数中，然后再定义线程去调用函数

from threading import Thread



t1 = Thread(target=函数1)#这里只写函数名，不要带括号

t1.start()



t2 = Thread(target=函数2)

t2.start()

先谢谢大佬，主要不是很明白他这个线程是直接写在我的这个代码的前边 还是说得另外再写一个，

首先要理解一下线程的概念，多线程可以同时异步执行，所以可以让你的程序处理逻辑变快，但前提是让不同的线程同时去处理不同的互不关联的逻辑。
像你上面描述的数据量很大，如果是有很多个单独的文件确实可以用多线程去处理，你可以为每个文件的读取逻辑单独写个函数，然后再去定义多个线程去执行函数。或者把某几个文件的读取放在同一个函数中用线程去执行，这样就可以多个文件同时处理了，速度也会大大加快，至于线程写在哪都无所谓。
还有一种情况就是如果你只有一个文件，而文件里的数据量很大有几千或几万行，那么这种情况是不适合用线程的，因为不管怎么说你都要从头读到尾去处理的。
但是看你上面的描述应该是第二种情况，是在你的文件里有大量的数据要去处理的吧，如果是这样的话，不太适合用线程的。如果非要用线程的话，可以把文件拆分成多个文件，然后再去写多个线程去处理。
写法可以参考如下：

import re 

from threading import Thread

  

def process_file():

    fo = open("1.txt", "r"); 

    co = open("2.txt", "r");

    colines = co.readlines();

  

    for line in fo.readlines():

        line = line.strip();

        matchObj = re.search( line, "%s" %  colines, re.M | re.I);

 

        if matchObj:

            print (line);

  

 

    fo.close();

    co.close();



t1 = Thread(target=process_file)#这里只写函数名，不要带括号

t1.start()

大佬这个文件拆分的话可以写好几个fo吗
fo = open("1.txt", "r"); 
fo = open("2.txt", "r"); 
fo = open("3.txt", "r"); 
fo = open("4.txt", "r"); 
co = open("5.txt", "r");
然后用这四个搞这一个，小弟没有系统学过跳的太快了 时常一脸懵

Quote: 引用 5 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 4 楼 一笑程序猴 的回复:

Quote: 引用 3 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 1 楼 一笑程序猴 的回复:

可以定义几个函数，把处理数据的逻辑放在函数中，然后再定义线程去调用函数

from threading import Thread



t1 = Thread(target=函数1)#这里只写函数名，不要带括号

t1.start()



t2 = Thread(target=函数2)

t2.start()

先谢谢大佬，主要不是很明白他这个线程是直接写在我的这个代码的前边 还是说得另外再写一个，

首先要理解一下线程的概念，多线程可以同时异步执行，所以可以让你的程序处理逻辑变快，但前提是让不同的线程同时去处理不同的互不关联的逻辑。
像你上面描述的数据量很大，如果是有很多个单独的文件确实可以用多线程去处理，你可以为每个文件的读取逻辑单独写个函数，然后再去定义多个线程去执行函数。或者把某几个文件的读取放在同一个函数中用线程去执行，这样就可以多个文件同时处理了，速度也会大大加快，至于线程写在哪都无所谓。
还有一种情况就是如果你只有一个文件，而文件里的数据量很大有几千或几万行，那么这种情况是不适合用线程的，因为不管怎么说你都要从头读到尾去处理的。
但是看你上面的描述应该是第二种情况，是在你的文件里有大量的数据要去处理的吧，如果是这样的话，不太适合用线程的。如果非要用线程的话，可以把文件拆分成多个文件，然后再去写多个线程去处理。
写法可以参考如下：

import re 

from threading import Thread

  

def process_file():

    fo = open("1.txt", "r"); 

    co = open("2.txt", "r");

    colines = co.readlines();

  

    for line in fo.readlines():

        line = line.strip();

        matchObj = re.search( line, "%s" %  colines, re.M | re.I);

 

        if matchObj:

            print (line);

  

 

    fo.close();

    co.close();



t1 = Thread(target=process_file)#这里只写函数名，不要带括号

t1.start()

大佬这个文件拆分的话可以写好几个fo吗
fo = open("1.txt", "r"); 
fo = open("2.txt", "r"); 
fo = open("3.txt", "r"); 
fo = open("4.txt", "r"); 
co = open("5.txt", "r");
然后用这四个搞这一个，小弟没有系统学过跳的太快了 时常一脸懵

貌似是不行，只能识别出来4

Quote: 引用 6 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 5 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 4 楼 一笑程序猴 的回复:

Quote: 引用 3 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 1 楼 一笑程序猴 的回复:

可以定义几个函数，把处理数据的逻辑放在函数中，然后再定义线程去调用函数

from threading import Thread



t1 = Thread(target=函数1)#这里只写函数名，不要带括号

t1.start()



t2 = Thread(target=函数2)

t2.start()

先谢谢大佬，主要不是很明白他这个线程是直接写在我的这个代码的前边 还是说得另外再写一个，

首先要理解一下线程的概念，多线程可以同时异步执行，所以可以让你的程序处理逻辑变快，但前提是让不同的线程同时去处理不同的互不关联的逻辑。
像你上面描述的数据量很大，如果是有很多个单独的文件确实可以用多线程去处理，你可以为每个文件的读取逻辑单独写个函数，然后再去定义多个线程去执行函数。或者把某几个文件的读取放在同一个函数中用线程去执行，这样就可以多个文件同时处理了，速度也会大大加快，至于线程写在哪都无所谓。
还有一种情况就是如果你只有一个文件，而文件里的数据量很大有几千或几万行，那么这种情况是不适合用线程的，因为不管怎么说你都要从头读到尾去处理的。
但是看你上面的描述应该是第二种情况，是在你的文件里有大量的数据要去处理的吧，如果是这样的话，不太适合用线程的。如果非要用线程的话，可以把文件拆分成多个文件，然后再去写多个线程去处理。
写法可以参考如下：

import re 

from threading import Thread

  

def process_file():

    fo = open("1.txt", "r"); 

    co = open("2.txt", "r");

    colines = co.readlines();

  

    for line in fo.readlines():

        line = line.strip();

        matchObj = re.search( line, "%s" %  colines, re.M | re.I);

 

        if matchObj:

            print (line);

  

 

    fo.close();

    co.close();



t1 = Thread(target=process_file)#这里只写函数名，不要带括号

t1.start()

大佬这个文件拆分的话可以写好几个fo吗
fo = open("1.txt", "r"); 
fo = open("2.txt", "r"); 
fo = open("3.txt", "r"); 
fo = open("4.txt", "r"); 
co = open("5.txt", "r");
然后用这四个搞这一个，小弟没有系统学过跳的太快了 时常一脸懵

貌似是不行，只能识别出来4

可以，但不要用同一个变量fo，换成fo1，fo2，fo3，fo4,，同样for循环的那个逻辑也写成4个，这样就可以定义4个函数和多线程处理了。

Quote: 引用 7 楼 一笑程序猴 的回复:

Quote: 引用 6 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 5 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 4 楼 一笑程序猴 的回复:

Quote: 引用 3 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 1 楼 一笑程序猴 的回复:

可以定义几个函数，把处理数据的逻辑放在函数中，然后再定义线程去调用函数

from threading import Thread



t1 = Thread(target=函数1)#这里只写函数名，不要带括号

t1.start()



t2 = Thread(target=函数2)

t2.start()

先谢谢大佬，主要不是很明白他这个线程是直接写在我的这个代码的前边 还是说得另外再写一个，

首先要理解一下线程的概念，多线程可以同时异步执行，所以可以让你的程序处理逻辑变快，但前提是让不同的线程同时去处理不同的互不关联的逻辑。
像你上面描述的数据量很大，如果是有很多个单独的文件确实可以用多线程去处理，你可以为每个文件的读取逻辑单独写个函数，然后再去定义多个线程去执行函数。或者把某几个文件的读取放在同一个函数中用线程去执行，这样就可以多个文件同时处理了，速度也会大大加快，至于线程写在哪都无所谓。
还有一种情况就是如果你只有一个文件，而文件里的数据量很大有几千或几万行，那么这种情况是不适合用线程的，因为不管怎么说你都要从头读到尾去处理的。
但是看你上面的描述应该是第二种情况，是在你的文件里有大量的数据要去处理的吧，如果是这样的话，不太适合用线程的。如果非要用线程的话，可以把文件拆分成多个文件，然后再去写多个线程去处理。
写法可以参考如下：

import re 

from threading import Thread

  

def process_file():

    fo = open("1.txt", "r"); 

    co = open("2.txt", "r");

    colines = co.readlines();

  

    for line in fo.readlines():

        line = line.strip();

        matchObj = re.search( line, "%s" %  colines, re.M | re.I);

 

        if matchObj:

            print (line);

  

 

    fo.close();

    co.close();



t1 = Thread(target=process_file)#这里只写函数名，不要带括号

t1.start()

大佬这个文件拆分的话可以写好几个fo吗
fo = open("1.txt", "r"); 
fo = open("2.txt", "r"); 
fo = open("3.txt", "r"); 
fo = open("4.txt", "r"); 
co = open("5.txt", "r");
然后用这四个搞这一个，小弟没有系统学过跳的太快了 时常一脸懵

貌似是不行，只能识别出来4

可以，但不要用同一个变量fo，换成fo1，fo2，fo3，fo4,，同样for循环的那个逻辑也写成4个，这样就可以定义4个函数和多线程处理了。

import re

from threading import Thread

   

def process_file():

 fo = open("1.txt", "r");

 fo1 = open("2.txt", "r");

 fo2 = open("3.txt", "r");

 fo3 = open("4.txt", "r");

co = open("5.txt", "r");

colines = co.readlines();

 

for line in fo.readlines():

 for line in fo1.readlines():

  for line in fo2.readlines():

   for line in fo3.readlines():

    line = line.strip();

    matchObj = re.search( line, "%s" %  colines, re.M | re.I);



    if matchObj:

        print (line);



fo.close();

co.close();



t1 = Thread(target=process_file)#这里只写函数名，不要带括号

t1.start()

大佬您看这么写行不，NameError: name 'fo' is not defined 一直报错这个，
我感觉这个代码贴出来可能会引起一阵狂笑

Quote: 引用 8 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 7 楼 一笑程序猴 的回复:

Quote: 引用 6 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 5 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 4 楼 一笑程序猴 的回复:

Quote: 引用 3 楼 穿袜子的猫和穿靴子的狗 的回复:

Quote: 引用 1 楼 一笑程序猴 的回复:

可以定义几个函数，把处理数据的逻辑放在函数中，然后再定义线程去调用函数

from threading import Thread



t1 = Thread(target=函数1)#这里只写函数名，不要带括号

t1.start()



t2 = Thread(target=函数2)

t2.start()

先谢谢大佬，主要不是很明白他这个线程是直接写在我的这个代码的前边 还是说得另外再写一个，

首先要理解一下线程的概念，多线程可以同时异步执行，所以可以让你的程序处理逻辑变快，但前提是让不同的线程同时去处理不同的互不关联的逻辑。
像你上面描述的数据量很大，如果是有很多个单独的文件确实可以用多线程去处理，你可以为每个文件的读取逻辑单独写个函数，然后再去定义多个线程去执行函数。或者把某几个文件的读取放在同一个函数中用线程去执行，这样就可以多个文件同时处理了，速度也会大大加快，至于线程写在哪都无所谓。
还有一种情况就是如果你只有一个文件，而文件里的数据量很大有几千或几万行，那么这种情况是不适合用线程的，因为不管怎么说你都要从头读到尾去处理的。
但是看你上面的描述应该是第二种情况，是在你的文件里有大量的数据要去处理的吧，如果是这样的话，不太适合用线程的。如果非要用线程的话，可以把文件拆分成多个文件，然后再去写多个线程去处理。
写法可以参考如下：

import re 

from threading import Thread

  

def process_file():

    fo = open("1.txt", "r"); 

    co = open("2.txt", "r");

    colines = co.readlines();

  

    for line in fo.readlines():

        line = line.strip();

        matchObj = re.search( line, "%s" %  colines, re.M | re.I);

 

        if matchObj:

            print (line);

  

 

    fo.close();

    co.close();



t1 = Thread(target=process_file)#这里只写函数名，不要带括号

t1.start()

大佬这个文件拆分的话可以写好几个fo吗
fo = open("1.txt", "r"); 
fo = open("2.txt", "r"); 
fo = open("3.txt", "r"); 
fo = open("4.txt", "r"); 
co = open("5.txt", "r");
然后用这四个搞这一个，小弟没有系统学过跳的太快了 时常一脸懵

貌似是不行，只能识别出来4

可以，但不要用同一个变量fo，换成fo1，fo2，fo3，fo4,，同样for循环的那个逻辑也写成4个，这样就可以定义4个函数和多线程处理了。

import re

from threading import Thread

   

def process_file():

 fo = open("1.txt", "r");

 fo1 = open("2.txt", "r");

 fo2 = open("3.txt", "r");

 fo3 = open("4.txt", "r");

co = open("5.txt", "r");

colines = co.readlines();

 

for line in fo.readlines():

 for line in fo1.readlines():

  for line in fo2.readlines():

   for line in fo3.readlines():

    line = line.strip();

    matchObj = re.search( line, "%s" %  colines, re.M | re.I);



    if matchObj:

        print (line);



fo.close();

co.close();



t1 = Thread(target=process_file)#这里只写函数名，不要带括号

t1.start()

大佬您看这么写行不，NameError: name 'fo' is not defined 一直报错这个，
我感觉这个代码贴出来可能会引起一阵狂笑

报错就对了

import re

from threading import Thread

co = open("5.txt", "r");

colines = co.readlines();



def process_file():

    fo = open("1.txt", "r");  

    for line in fo.readlines():

        line = line.strip();

        matchObj = re.search(line, "%s" % colines, re.M | re.I);

        if matchObj:

            print(line);   

    fo.close();



def process_file1():

    #同理



def process_file2():   

    #同理



def process_file3():   

     #同理

    

co.close();



t = Thread(target=process_file)  # 这里只写函数名，不要带括号

t.start()



#同样分别写4个用不同的变量调用不同的函数

对的，定义那4个线程最好用4个不同的变量，不过这样也可以，没什么问题
你运行完用多长时间，是不是数据太少，看上去不明显？，总之用线程肯定要比你原来那样写要快的。

对的，定义那4个线程最好用4个不同的变量，不过这样也可以，没什么问题
你运行完用多长时间，是不是数据太少，看上去不明显？，总之用线程肯定要比你原来那样写要快的。

妥了大哥，还有最后一个小问题这个代码现在的功能是搜索出重复的 能不能加点什么删点什么变成删除啊，就是A里边是一堆词，苹果，香蕉，梨 西瓜。B文档是句子 我有一个苹果，现在是可以显示出 苹果，能不能改成在B文档中把苹果这个重复词给删除掉，变成我有一个

以这个例子来说，
如果txt文件不大，用线程根本无意义
如果txt文件很大，把r改成rb，速度会快上好几倍。

优化方向性错误。

超大文件读取，可以看看我以前写的一个博文。

再python中，线程一般用于io密集型。进程用于cpu密集型。但python的文件读取操作本身效率已经非常高了。
re的字符串操作效率也很高。
所以我说以本例来说，增加线程完全无必要。

以这个例子来说，
如果txt文件不大，用线程根本无意义
如果txt文件很大，把r改成rb，速度会快上好几倍。

优化方向性错误。

超大文件读取，可以看看我以前写的一个博文。

再python中，线程一般用于io密集型。进程用于cpu密集型。但python的文件读取操作本身效率已经非常高了。
re的字符串操作效率也很高。
所以我说以本例来说，增加线程完全无必要。

Quote: 引用 12 楼 穿袜子的猫和穿靴子的狗 的回复:

妥了大哥，还有最后一个小问题这个代码现在的功能是搜索出重复的 能不能加点什么删点什么变成删除啊，就是A里边是一堆词，苹果，香蕉，梨 西瓜。B文档是句子 我有一个苹果，现在是可以显示出 苹果，能不能改成在B文档中把苹果这个重复词给删除掉，变成我有一个

只能给你个大概思路
这种情况直接在原文件上操作是不大可能的，这时就需要第三个文件C，把内容写到C文件里，不需要做修改的可以直接写进去，需要修改的部分修改后写进去（也就是if里面的内容）。
如果匹配到以后想把某个词删掉，那可以直接用replace函数直接替换成空就可以了

你这个代码估计调试无法通过。
因为 bytes的 re 必须用bytes的patten

再改改re的，"%s"这有问题
如果我记忆没错的话，%s再python3.x的某个x后不支持。另外，搜索bytes，patten 必须用
bytes 也就是 b""

你这个程序要干嘛？ 判断fo的行是否存在于co中吗？

大佬。就在我的代码基础上把r换成rb后报错，这个该怎么办 

Quote: 引用 15 楼 穿袜子的猫和穿靴子的狗 的回复:

大佬。就在我的代码基础上把r换成rb后报错，这个该怎么办 

说中了，re的操作中，如果目标为str，则pattern必须为str。如果目标为bytes,则pattern必须为bytes 。明白问题所在了吧？
用r读出来的是str，用rb读出来的是bytes

]是的呢，太多词了 手动过不过来，想看看哪些重复的，又不会写 到处抄代码 

Quote: 引用 19 楼 穿袜子的猫和穿靴子的狗 的回复:

]是的呢，太多词了 手动过不过来，想看看哪些重复的，又不会写 到处抄代码 

关键看这2个文件有多大。
一大一小，在大文件中搜寻小文件行？
差不多大，找两个文件中相同的行？

如果只是相同行比较，那就比较简单：

with open("key.txt","rb") as f:

	colines = f.readlines()

colines = [line.strip(b"\r\n") for line in colines]

print(colines)

with open("source.txt","rb") as f:

	for line in f:

		if line.strip(b"\r\n") in colines:

			print(line.strip(b"\r\n"))

key很大，source一般。
25M貌似python撑的住，照上面的例子改改判断 也就if部分，再看看速度
速度不够再帮你继续优化。

对比的是包含呢 B的句子里包含哪些A里面的词，好像是对比不成呢

Quote: 引用 25 楼 穿袜子的猫和穿靴子的狗 的回复:

对比的是包含呢 B的句子里包含哪些A里面的词，好像是对比不成呢

我写的只是2行内容相同的比较，你要自己改if的。
你的思路是把小的source.txt 读入内存，形成字符串，然后，遍历key.txt 看大字符串中是否存在key对吧。

A.txt 给5个样本数据
B.txt 给5个样本数据

好的非常感谢大佬指点 我研究一下这个该怎么弄

import re





with open("source.txt", "rb")as f:

	source = f.readlines()

sourceSt = b"".join(source)



with open("key.txt", "rb") as f:

	for key in f:

		key = key.strip()

		mObj = re.search(key, sourceSt,re.M|re.I)

		if mObj:

			print(key)

试一试速度吧

Quote: 引用 27 楼 穿袜子的猫和穿靴子的狗 的回复:

好的非常感谢大佬指点 我研究一下这个该怎么弄

如果#28的速度不理想，先开任务管理器看看，cpu占用多少。
如果运行的时候cpu占满了，估计你得考虑的是算法优化而不是开线程什么的。
如果cpu没占满，得考虑的是进程优化而不是线程优化。

import re





with open("source.txt", "rb")as f:

	source = f.readlines()

sourceSt = b"".join(source)



with open("key.txt", "rb") as f:

	for key in f:

		key = key.strip()

		mObj = re.search(key, sourceSt,re.M|re.I)

		if mObj:

			print(key.decode("gbk"))

错误不是由于中文问题，而是由于你的key中，包含re不允许的字符，比如需要转义的字符。
print的出来的由于是bytes，所以显示为内码形式，加个decode("gbk")就能显示出来。

写错了

print(f"error key:{key.decode('gbk')}")

写错了

print(f"error key:{key.decode('gbk')}")

import re





with open("source.txt", "rb")as f:

	source = f.readlines()

sourceSt = b"".join(source)



with open("key.txt", "rb") as f:

	for key in f:

		key = key.strip()

		try:

			mObj = re.search(key, sourceSt,re.M|re.I)

		except Exception:

			print(f"error key:{key.decode("gbk")}")



		if mObj:

			print(key.decode("gbk"))

太刺激了，这个弄完我也要好好学习python，非常非常感谢大佬耐心解答，

Quote: 引用 38 楼 穿袜子的猫和穿靴子的狗 的回复:

太刺激了，这个弄完我也要好好学习python，非常非常感谢大佬耐心解答，

with open("source.txt", "rb")as f:

    source = f.readlines()

sourceSt = b"".join(source)

 

with open("key.txt", "rb") as f:

    for key in f:

        key = key.strip()

        if key in sourceSt:

        	print(key.decode('gbk'))

由于你的key是一行一个key这种特殊存在，可能这样写会更简洁，更快一点，大概可能50%的速度提升吧。
另外不建议查到就print，如果查到的key过多（比如key.txt中重复的很多），速度会很慢。

大佬快给我感动哭了，快太多了简直 python可以在这种本身的代码上增加功能吗，比如说我要增加个找到了直接导出到一个TXT文本，或者直接在B文档中删除找到的词，

Quote: 引用 40 楼 穿袜子的猫和穿靴子的狗 的回复:

大佬快给我感动哭了，快太多了简直 python可以在这种本身的代码上增加功能吗，比如说我要增加个找到了直接导出到一个TXT文本，或者直接在B文档中删除找到的词，

你这个程序结构，再source中删除比较麻烦，因为你source是作为一个整体在被搜索，

删Source思路：
用 sourceSt.find来查找key，这样可以搜索到第一次出现key的位置。然后用这个位置数对sourceSt做切片，然后查询切片内\r\n的数量，基本上可以定位行数，保存这些行数，最后遍历一遍source.txt文件，就能删除文档中包含了key的行。

删Key思路：
遍历的时候，如果查到不输出到NewKey.txt,如果查不到，输出到NewKey.txt

输出到txt文本：
循环前定义一个list

rsltList = []

print(key.decode('gbk'))

输出时，同时将找到的key保存入List

rsltList.append(key.decode("GBK"))

最后得到一个查找到的rsltList
用with open("rslt.txt","wb") as f:
打开输出文件
f.writelines 可以直接将rsltList保存到文件，注意：如果需要一行一个key，rsltList的每行的\r\n要手动添加给每个item
rsltList.appent(f'{key.decode("GBK")}\r\n')