精华内容
下载资源
问答
  • word 查找

    2015-05-11 00:40:52
    word通配符 >代表以什么结尾 en> 以en结尾 可以找到pen ?代表单个任意字符 *多个任意字符 @包含一个以上前一字符  []包含中间任意一个 [a] [!]包含指定字符以外字符 ...()多个关键词组合搜索 找啊啊开头哦结尾

    word通配符

    >代表以什么结尾 en> 以en结尾 可以找到pen

    <代表以什么开头

    ?代表单个任意字符

    *多个任意字符

    @包含一个以上前一字符 

    []包含中间任意一个 [a]

    [!]包含指定字符以外字符 [!a] 

    [-] 包含指定范围单一字符 [a-z]

    [!-]不包含指定范围单一字符[!a-z]

    {}前一字符重复次数 {1}a

    ()多个关键词组合搜索 <(啊啊)*(哦)> 找啊啊开头哦结尾



    展开全文
  • 多个Word文档中查找指定文件内容

    万次阅读 热门讨论 2016-08-09 13:20:41
    文件分捡工具,可以根据你的需要设置不同的关键词,如上图,只要搜索指定的关键词(以逗号分隔),就可以实现对一目录中的所有简历文件进行归类统计,统计每简历中文件出现的次数,并可以按关键词类别或者匹配的...

    文档内容检索工具版本已更新,下面的下载地址链接已更新

    实现了简单的Word文档查找的功能,可指定多个关键词在多个Word文档中对关键词进行查找,功能比较简单,能够查找到匹配的文字,并统计匹配关键词的个数。

    工具下载地址:https://download.csdn.net/download/urhero/12461582

    下面详细说说如何使用这个工具完成多个文档中查找关键词,首先点待分捡文件目录后面的浏览按钮,选择好word文档所在的目录,输出的分捡目录,可以选择也可以使用默认的路径,下一步,输入分捡标签,也就是要查找的关键词,比如,“期末模拟试题,中考摸底”,点击“筛选”按钮,工具将会对指定的目录下的所有Word文档进行查找,并显示某个指定的关键词在每个文档中的匹配个数,方便我们确定哪个文档才是我们真正要找的,当文件数量庞大的时候,这个工具的自动处理就显得非常有用。点击不同的列标题,可以根据某一列的值进行排序,这样更便于结果的比较,如果文档列表较庞大,按文件名进行排序,或者按关键词分组显示将变得很有必要。最后通过点击“分捡”按钮,可以实现将一个目录下的众多文档,按照各指定的关键词进行分类整理,放入不同的目录中,给文档管理者带来极大方便。

    做这个工具只是希望使大家的工作变得更加轻松,比如老师的试卷分类管理、学生的档案分类管理、企业人员的简历分专业分捡等等都可能会用到这样的软件工具,如果靠人手工一个文档一个文档的打开,查找,统计个数,最好整理出Excel表格,将是非常繁琐的工作,希望这样一款小工具,能为大家的工作生活带来一点点便捷。

    
    展开全文
  • 上一次我写到 例题之进程文件查找单词,然后这篇博文来讲解如何用线程文件查找关键词 自己的尝试 在了解到进程解决文件的查找关键字的解决思路后,我尝试自己写了一下线程的解决方法(这方法并没提高多少...

    今天继续《Python3程序开发指南(第二版)》的多线程例题讲解.
    上一次我写到 例题之多进程文件查找单词,然后这篇博文来讲解如何用多线程文件查找关键词

    自己的尝试

    在了解到多进程解决多文件的查找关键字的解决思路后,我尝试自己写了一下多线程的解决方法(这个方法并没提高多少效率,想看原书的解决方请直接跳到后面)

    大概思路

    1. 查找函数grep_word()进行参数的处理,获取查找单词,查找文件列表
    2. grep_word()生成线程对象(threading.Thread的子类)列表
    3. 给每个线程分配固定数量的文件,使用块方法进行单词查找
    4. 便于测试,使用Thread.join()使得主程序比子线程晚结束
      代码没什么复杂,就是将多进程解决方法中的进程改成了线程,直接贴代码,同时也补充了一些注释
      但事实上和多进程没有什么区别,因为多进程也是多线程的一种,只不过多进程不能使用共有变量而已.

    补充一点,这样子好像会造成死锁,很幸运,我遇到了o(╯□╰)o,具体情况我还需要研究一下,所以看书上用的方法吧

    """
        作者: 子狼  日期:    2019/8/8 17:38
        项目名称:   programming_in_python3
        文件名称:   grepword
    """
    
    import os
    import sys
    import time
    import optparse
    from threading import Thread
    
    # Thread子类,相比直接使用Thread类可以更好的扩展
    class GrepWordThread(Thread):
        def __init__(self, number, word='default'):
            Thread.__init__(self)
            self.number = number  # 用于调试
            self.BLOCK_SIZE = 8000  # 分块读取的大小
            self.filenames = []  # 需要处理的文件列表
            self.word = word  # 需要查找的单词
    
        def add_filename(self, filename):
            self.filenames.append(filename)
    
        def set_word(self, word):
            self.word = word
    
        def run(self):
            for filename in self.filenames:
                try:
                    # 以二进制模式进行读操作
                    with open(filename, 'rb') as fh:
                        # print("begin find file {0}{1}:".format(self.number, filename))
                        previous = fh.read(0).decode('utf-8', 'ignore')
    
                        while True:
                            # 如果文件很大,一次性读取这些文件会出现问题,所以我们以块的形式读入每个文件,
                            # 这个方法的另一个好处是如果提前出现了可以不用往下找,因为我们目的只是判断是否存在
                            current = fh.read(self.BLOCK_SIZE)
                            # 文件读取完毕
                            if not current:
                                break
                            # 假定所有文件都是用utf-8编码
                            current = current.decode('utf-8', 'ignore')
                            if (self.word in current) or (self.word in previous[-len(self.word):] + current[:len(self.word)]):
                                print("{0}{1}".format(self.number, filename))
                                break
                            if len(current) != self.BLOCK_SIZE:
                                break
                            previous = current
    
                        # print("end find file {0}{1}:".format(self.number, filename))
                except EnvironmentError as err:
                    print("ERROR: {0}{1}{2}".format(self.number, filename, err))
    
    
    def parse_option(args_list=None):
        args_list = args_list if args_list else sys.argv[1:]
        parse = optparse.OptionParser()
        parse.add_option("-r", "--recurse", dest="recurse", default="True", help="subdirectory recursion or not" )
        parse.add_option("-n", "--numprocess", type=int, dest="numprocess", default=7, help="number of process")
        # parse.add_option("-f", "--filename", dest="filename", help="Filename that need to be searched") 文件直接在所有参数后面输入
        parse.add_option("-w", "--word", dest="word", help="Searched words")
        parse.add_option("-d", "--debug", dest="debug", default="debug", help="if now debug")
    
        options, args = parse.parse_args(args_list)
        # print("123")
        # 返回 相应的opts, 查询词, 未匹配的词
        return options, options.word, args
    
    
    def get_files(args, recurse):
        file_list = []
        # 假设目录一定以/结尾且不存在小数点
        for filename in args:
            # isfile, isdir...
            if os.path.isfile(filename):
                file_list.append(filename)
            # recurse
            if "true" in recurse.lower() and os.path.isdir(filename):
                for root, dirs, files in os.walk(filename):
                    for file in files:
                        file_list.append(str(os.path.join(root, file)))
        # for item in file_list:
        #     print(item)
        return file_list
    
    
    def grep_word():
        # 手动输入参数
        args_list = [item for item in input().split()]
        print(time.clock())
        # 获取用户指定的命令行选项, 待搜索单词, 待搜索文件列表
        opts, word, args = parse_option(args_list)
        # 带读取的文件列表(文件列表, 是否递归搜索)
        file_list = get_files(args, opts.recurse)
    
        # 每个进程被分配的文件数量
        files_per_process = len(file_list) // opts.numprocess
        # 分片(多余的文件给第一个进程)
        start, end = 0, (files_per_process + (len(file_list) % opts.numprocess))
        number = 1
        threads = []
    
        while start < len(file_list):
            thread = GrepWordThread(number)
            threads.append(thread)
            thread.set_word(word)
            for filename in file_list[start:end]:
                thread.add_filename(filename)
            thread.start()  # ???会死锁???
            number += 1
            start, end = end, end + files_per_process
    
        for thread in threads:
            thread.join()
    
    
    if __name__ == '__main__':
        grep_word()
    
        print(time.clock())
    

    书上的方法

    大概思路

    使用Queue保存文件列表, 进程不断从queue中取文件, 比如: 进程A开始读取queue.get(),同时queue.pop(),由于A涉及到文件读写,被阻塞, 进程B读取queue.get(),也被阻塞,在某个进程n被阻塞的时候,A进程执行完之前读取的文件,并使用queue.task_done()通知此任务已被完成, 再次读取一个新的queue.get(),n+1进程继续读取被阻塞, 之前被阻塞的进程由于处理文件的大小不一样, 执行结束时间也不一样, 但是都是执行完本身的任务立刻执行下一个任务. 此方法的好处是, queue自带锁机制, 而且如果有个文件特别大, 可以一个进程从头执行到尾,其他进程执行其他任务,相比任务分配的多进程方法,这个方法更加灵活.

    """
        作者: 王海霞  日期:    2019/8/8 21:54
        项目名称:   programming_in_python3
        文件名称:   grepword_t
    """
    import sys
    from queue import Queue
    from threading import Thread
    import optparse
    import os
    
    
    def parse_option(args_list=None):
        args_list = args_list if args_list else sys.argv[1:]
        parse = optparse.OptionParser()
        parse.add_option("-r", "--recurse", dest="recurse", default="True", help="subdirectory recursion or not" )
        parse.add_option("-n", "--numprocess", type=int, dest="numprocess", default=7, help="number of process")
        # parse.add_option("-f", "--filename", dest="filename", help="Filename that need to be searched") 文件直接在所有参数后面输入
        parse.add_option("-w", "--word", dest="word", help="Searched words")
        parse.add_option("-d", "--debug", dest="debug", default="false", help="if now debug")
    
        options, args = parse.parse_args(args_list)
        # print("123")
        # 返回 相应的opts, 查询词, 未匹配的词
        return options, options.word, args
    
    
    def get_files(args, recurse):
        file_list = []
        # 假设目录一定以/结尾且不存在小数点
        for filename in args:
            # isfile, isdir...
            if os.path.isfile(filename):
                file_list.append(filename)
            # recurse
            if "true" in recurse.lower() and os.path.isdir(filename):
                for root, dirs, files in os.walk(filename):
                    for file in files:
                        file_list.append(str(os.path.join(root, file)))
        # for item in file_list:
        #     print(item)
        return file_list
    
    
    class Worker(Thread):
        def __init__(self, work_queue, word, number):
            Thread.__init__(self)
            self.work_queue = work_queue
            self.word = word
            self.number = number
            self.BLOCK_SIZE = 8000
    
        def run(self):
            while True:
                try:
                    filename = self.work_queue.get()
                    self.process(filename)
                except EnvironmentError as err:
                    print("{0}{1}".format(self.number, err))
                finally:
                    # 表示以前排队的任务已完成。
                    # 由队列使用者线程使用。
                    # 对于用于获取任务的每个get(),对task_done()的后续调用会告知队列该任务的处理已完成。
                    # 如果join()当前正在阻塞,则它将在所有项目都已处理后恢复(这意味着已为每个已放入队列的项目收到task_done()调用)。
                    # 如果调用的次数超过队列中放置的项目,则引发ValueError。
                    '''Indicate that a formerly enqueued task is complete.
    
                    Used by Queue consumer threads.  
                    For each get() used to fetch a task, a subsequent call to task_done() tells the queue that the 
                        processing on the task is complete.
    
                    If a join() is currently blocking, it will resume when all items
                    have been processed (meaning that a task_done() call was received
                    for every item that had been put() into the queue).
    
                    Raises a ValueError if called more times than there were items
                    placed in the queue.
                    '''
                    self.work_queue.task_done()
    
        def process(self, filename):
            try:
                # 以二进制模式进行读操作
                with open(filename, 'rb') as fh:
                    # print("begin find file {0}{1}:".format(self.number, filename))
                    previous = fh.read(0).decode('utf-8', 'ignore')
    
                    while True:
                        # 如果文件很大,一次性读取这些文件会出现问题,所以我们以块的形式读入每个文件,
                        # 这个方法的另一个好处是如果提前出现了可以不用往下找,因为我们目的只是判断是否存在
                        current = fh.read(self.BLOCK_SIZE)
                        # 文件读取完毕
                        if not current:
                            break
                        # 假定所有文件都是用utf-8编码
                        current = current.decode('utf-8', 'ignore')
                        if (self.word in current) or (self.word in previous[-len(self.word):] + current[:len(self.word)]):
                            print("{0}{1}".format(self.number, filename))
                            break
                        if len(current) != self.BLOCK_SIZE:
                            break
                        previous = current
    
                    # print("end find file {0}{1}:".format(self.number, filename))
            except EnvironmentError as err:
                print("ERROR: {0}{1}{2}".format(self.number, filename, err))
    
    
    def grepword():
        args_list = [item for item in input().split()]
        opts, word, args = parse_option(args_list)
        file_list = get_files(args, opts.recurse)
        work_queue = Queue()
        for i in range(opts.numprocess):
            number = "{0}:".format(i+1) if "true" in opts.debug.lower() else ""
            worker = Worker(work_queue, word, number)
            # 守护进程
            # 主程序在没有非守护进程的时候会退出
            # 在start()前设置
            # The entire Python program exits when no alive non-daemon threads are left.
            worker.daemon = True
            worker.start()
        for filename in file_list:
            work_queue.put(filename)
        work_queue.join() # 与Queue.task_done配合使用
    
    
    if __name__ == '__main__':
        grepword()
    
    展开全文
  • 查找.docx文件中的关键字,并且输出结果,代码如下: <code>from docx import Document import os,sys ...关键词word次出现,只输出一结果 请各位老师、大神帮帮忙</p>
  • Word 文件搜索器1.0

    2016-08-08 16:52:03
    2.在简历目录中对多个简历文件进行关键词搜索,并根据匹配的结果进行相应的分捡处理。 工具特点:自动化分捡处理,同时过滤结果中可以直接打开文档查看。 此版本修改了上个版本中的一些问题,并将Word检索工作放到...
  • Word、PPT、Excel,哪一值得你花精力去学习? 我认为是Word,因为Word 软件的使用频率高,所以学习以后为你的办公能力带来的提升很大,学会Word 能够为你节约很的工作时间。 有一段子是这么说的——“我很小...
  • 搜索引擎被人们当做了在网上查找信息的重要手段,通过搜索引擎系统人们可以在浩瀚的网络海洋中第一时间找到自己真正想要的信息,并且搜索引擎的智能以及现在网页的特性使得人们只要输入相关的词语(即关键词)就可以...
  • 我的查找相关文章的方法 要求我传一代表文章内容的字符串作为对比参数。 难道我在显示每篇文章之前都要先把 该文章的所有内容传给 查找相关文章的方法,然后获得相关文章列表吗? ...
  • 2.在简历目录中对多个简历文件进行关键词搜索,并根据匹配的结果进行相应的分捡处理。 工具特点:自动化分捡处理,同时过滤结果中可以直接打开文档查看。 此版本修改了上个版本中的一些问题,并将Word检索工作放到...
  • FileFilter简介:使用此工具可以根据输入的关键词(以逗号分开),在word文档中匹配筛选关键词,并给出关键词匹配查找到的个数,根据目标关键词的匹配情况将根据分捡条件自动将简历分捡到不同的目录中,方便使用。...
  •  分组统计:按照某一个字段或者多个字段对记录进行分组,让浏览阅读更加的清晰。并且对相同分组的记录进行多种数据的统计,避免必须通过报表才能统计,更直接简单。  导出报表:任何报表数据都可以导出到多种格式...
  • Oracle全文检索.rar

    2019-07-09 08:15:42
    Oracle Text 使Oracle9i 具备了强大的文本检索能力和智能化的文本管理能力,Oracle Text 是Oracle9i 采用的新名称,在oracle8/8i 中被称为oracle intermedia text,oracle8 ...该索引进程分为多个阶段,如下图 ......
  • Linux 查询日志 关键字出现次数

    万次阅读 2018-06-11 17:51:43
    两种方法:第一种:perl -e '$/=undef...' filenametheWord是你要搜索的词,一般是异常信息,filename是日志名称,第二种:查找单个关键词:grep -o objStr filename|wc -l查找多个关键字 直接用| 链接起来即可gr...


    两种方法:

    第一种:

    perl -e '$/=undef;$_=<>; printf "$&:%dn", s/$&//g while /theWord/;' filename


    theWord是你要搜索的词,一般是异常信息,

    filename是日志名称,

    第二种:

    查找单个关键词:

    grep -o objStr  filename|wc -l

    查找多个关键字  直接用| 链接起来即可

    grep -o ‘objStr1|objStr2'  filename|wc -l  


    展开全文
  • 有时候记住了内容一个两个关键词,但是忘记了文件在哪里,这种情况就可以找出来了。 文件内容检索 Lucense 分词框架 使用方法 安装一下,其实就是解压一下,创建一个桌面快捷方式 搜索的时候,输入关键字,选择...
  • 【7】多个word格式(含图片)(doc):自动排版,文件中含有图片,无需连网,每篇博文一个word文件。 【8】单个word格式(含图片)【《博客书》】【强烈推荐】(doc):博客书格式,自动排版,文件中含有图片,无需连网...
  • 【7】多个word格式(含图片)(doc):自动排版,文件中含有图片,无需连网,每篇博文一个word文件。 【8】单个word格式(含图片)【《博客书》】【强烈推荐】(doc):博客书格式,自动排版,文件中含有图片,无需连网...
  • 1.5、增加表格筛选功能,之前项目里表格数量很不好拖拉滚动跳找到,现在通过输入关键词查找过滤了。 1.6、增加一项目目录按钮,点击后直接打开项目根目录。 1.7、增加一数据库属性的选项卡,显示数据库连接...
  • 博客备份工具

    2013-04-24 14:20:21
    【7】多个word格式(含图片)(doc):自动排版,文件中含有图片,无需连网,每篇博文一个word文件。 【8】单个word格式(含图片)【《博客书》】【强烈推荐】(doc):博客书格式,自动排版,文件中含有图片,无需连网...
  • 通过windows的资源管理器或outlook等也可以查找和浏览文件,但是,如果要按照内容查找,则要么不支持按内容查找,要么检索速度太慢,要么建索引太麻烦。即使找到,查看起来一打开也很不方便。本软件弥补了...
  •  分组统计:按照某一个字段或者多个字段对记录进行分组,让浏览阅读更加的清晰。并且对相同分组的记录进行多种数据的统计,避免必须通过报表才能统计,更直接简单。  导出报表:任何报表数据都可以导出到多种...
  • 在同一个文献编号下将多个参考书目编组 在一个文献下用数字标示文字摘记 允许匿名工作选项 缩进选项 作者名或标题首字母大写选项 包含超过2300个文献风格:EndNote 为重要期刊提供超过2300种预定义的文献风格。每个...
  • struct key //为每个关键词创造一个节点 { int id; char key[20]; int find_number; place *places; }; key_node key_information[1000000]; struct file_inf //搜索文件的序号 { int number; ...
  • 自己动手写搜索引擎(罗刚著).doc

    热门讨论 2011-04-18 12:07:25
    4.2.3 Word文件 82 4.2.4 Rtf文件 82 4.2.5 Excel文件 83 4.2.6 PowerPoint文件 84 4.3 流媒体内容提取 85 4.3.1 音频流内容提取 85 4.3.2 视频流内容提取 87 4.4 抓取限制应对方法 89 4.5 本章小结 90 第5章 自然...
  • 原理:将目标文本按行分隔后,把各行文本分配到多个 Python 进程并行分词,然后归并结果,从而获得分词速度的可观提升 基于 python 自带的 multiprocessing 模块,目前暂不支持 Windows 用法: jieba.enable_...
  • 大话数据结构

    2018-12-14 16:02:18
    很多年前我们的科学家觉得像这种有多个0和1重复字符的字符串,却需要挨个遍历的算法,是非常糟糕的事情。 5.7.1kmp模式匹配算法原理 135 5.7.2next数组值推导 139 5.7.3kmp模式匹配算法实现 141 5.7.4kmp模式...
  • 情感分析-实体链接等)、word2word:(Python)方便易用的语言词-词对集:62种语言/3,564个多语言对、语音识别语料生成工具:从具有音频/字幕的在线视频创建自动语音识别(ASR)语料库、构建医疗实体识别的模型(包含...
  • 如果同一个名字有多个可能对应的实体("打球的李娜和唱歌的李娜不是一个人"),可以设置keep_all=True来保留多个候选,后面可以再采用别的策略消歧,见el_keep_all() 如果连接到的实体过多,其中有一些明显不合理,...
  • 试试“NOT 关键词”的查找方式。 列表显示无规则?点击表头就可排序,AJAX的哦。 自主开发的客户端采集软件,不占服务器资源。 一集采集远程图片,不用担心盗链或服务器稳定靠成图片无法显示的问题。   ...
  • 试试“NOT 关键词”的查找方式。 列表显示无规则?点击表头就可排序,AJAX的哦。 自主开发的客户端采集软件,不占服务器资源。 一集采集远程图片,不用担心盗链或服务器稳定靠成图片无法显示的问题。   ...
  • 蓝色博客网站 v1.0.zip

    2019-07-09 02:34:03
    试试“NOT 关键词”的查找方式。 列表显示无规则?点击表头就可排序,AJAX的哦。 自主开发的客户端采集软件,不占服务器资源。 一集采集远程图片,不用担心盗链或服务器稳定靠成图片无法显示的问题。   ...

空空如也

空空如也

1 2 3
收藏数 53
精华内容 21
关键字:

word查找多个关键词