pyxllib 0.0.43__py3-none-any.whl → 0.3.197__py3-none-any.whl

pyxllib/{sitepackages.py → prog/sitepackages.py}

@@ -2,20 +2,22 @@
 # -*- coding: utf-8 -*-
 # @Author : 陈坤泽
 # @Email  : 877362867@qq.com
-# @Data   : 2020/05/30 09:36
+# @Date   : 2020/05/30 09:36
 
 
 r"""
+一个旧模块，用来把pyxllib自动配置到 site-package 的工具
+使用 python setup.py develop 策略后就不太需要了
+
 除了使用pip install pyxllib，
 还可以下载最新源代码，然后用该脚本将pyxllib配置到site-packages里，便于索引使用
 """
 
-
 import os
 import site
 
 
-def add_project_to_sitepackages(project_path = os.path.dirname(__file__)):
+def add_project_to_sitepackages(project_path=os.path.dirname(__file__)):
     """ 将制定项目配置到sitepackages目录
     :param project_path: 项目路径
         默认本脚本所在的目录为项目路径

pyxllib/prog/specialist/__init__.py

@@ -0,0 +1,391 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2021/06/06 18:40
+
+
+from pyxllib.prog.specialist.common import *
+from pyxllib.prog.specialist.xllog import *
+from pyxllib.prog.specialist.browser import *
+from pyxllib.prog.specialist.bc import *
+from pyxllib.prog.specialist.tictoc import *
+from pyxllib.prog.specialist.datetime import *
+
+import concurrent.futures
+import os
+import re
+import subprocess
+import time
+from statistics import mean
+from threading import Thread
+
+from tqdm import tqdm
+import requests
+from humanfriendly import parse_size
+
+from pyxllib.prog.newbie import human_readable_size
+from pyxllib.prog.pupil import get_installed_packages, aligned_range, percentage_and_value
+from pyxllib.prog.xlosenv import XlOsEnv
+from pyxllib.file.specialist import cache_file
+
+
+def mtqdm(func, iterable, *args, max_workers=1, check_per_seconds=0.01, **kwargs):
+    """ 对tqdm的封装，增加了多线程的支持
+
+    这里名称前缀多出的m有multi的意思
+
+    :param max_workers: 默认是单线程，改成None会自动变为多线程
+        或者可以自己指定线程数
+        注意，使用负数，可以用对等绝对值数据的“多进程”
+    :param smoothing: tqdm官方默认值是0.3
+        这里关掉指数移动平均，直接计算整体平均速度
+        因为对我个人来说，大部分时候需要严谨地分析性能，得到整体平均速度，而不是预估当前速度
+    :param mininterval: 官方默认值是0.1，表示显示更新间隔秒数
+        这里不用那么频繁，每秒更新就行了~~
+    :param check_per_seconds: 每隔多少秒检查队列
+        有些任务，这个值故意设大一点，可以减少频繁的队列检查时间，提高运行速度
+    整体功能类似Iterate
+    """
+
+    # 0 个人习惯参数
+    kwargs['smoothing'] = kwargs.get('smoothing', 0)
+    kwargs['mininterval'] = kwargs.get('mininterval', 1)
+
+    if max_workers == 1:
+        # 1 如果只用一个线程，则不使用concurrent.futures.ThreadPoolExecutor，能加速
+        for x in tqdm(iterable, *args, **kwargs):
+            func(x)
+    else:
+        # 2 默认的多线程运行机制，出错是不会暂停的；这里对原函数功能进行封装，增加报错功能
+        error = False
+
+        def wrap_func(x):
+            nonlocal error
+            try:
+                func(x)
+            except Exception as e:
+                error = e
+
+        # 3 多线程/多进程 和 进度条 功能的结合
+        if max_workers > 1:
+            executor = concurrent.futures.ThreadPoolExecutor(max_workers)
+            for x in tqdm(iterable, *args, **kwargs):
+                while executor._work_queue.qsize():
+                    if check_per_seconds:
+                        time.sleep(check_per_seconds)
+                executor.submit(wrap_func, x)
+                if error:
+                    raise error
+        else:
+            executor = concurrent.futures.ProcessPoolExecutor(-max_workers)
+            for x in tqdm(iterable, *args, **kwargs):
+                # while executor._call_queue.pending_work_items:
+                #     if check_per_seconds:
+                #         time.sleep(check_per_seconds)
+                executor.submit(wrap_func, x)
+                if error:
+                    raise error
+
+        executor.shutdown()
+
+
+def distribute_package(root, version=None, repository=None, *,
+                       upload=True,
+                       version_file='setup.py',
+                       delete_dist=True):
+    """ 发布包的工具函数
+
+    :param root: 项目的根目录，例如 'D:/slns/pyxllib'
+        根目录下有对应的 setup.py 等文件
+    :param repository: 比如我配置了 [xlpr]，就可以传入 'xlpr'
+    :param version_file: 保存版本号的文件，注意看正则规则，需要满足特定的范式，才会自动更新版本号
+    :param delete_dist: 上传完是否自动删除dist目录，要检查上传包是否有遗漏时，要关闭
+    """
+    import sys
+    from pyxllib.file.specialist import XlPath
+
+    # 1 切换工作目录
+    os.chdir(str(root))
+
+    # 2 改版本号
+    if version:
+        f = XlPath(root) / version_file
+        s = re.sub(r"(version\s*=\s*)(['\"])(.+?)(\2)", fr'\1\g<2>{version}\4', f.read_text())
+        f.write_text(s)
+
+    # 3 打包
+    subprocess.run(f'{sys.executable} setup.py sdist')
+
+    # 4 上传
+    if upload:
+        # 上传
+        cmd = 'twine upload dist/*'
+        if repository:
+            cmd += f' -r {repository}'
+        subprocess.run(cmd)
+        # 删除打包生成的中间文件
+        if delete_dist:
+            XlPath('dist').delete()
+        XlPath('build').delete()
+
+        # 这个不能删，不然importlib会读取不到模块的版本号
+        # [d.delete() for d in XlPath('.').select_dirs(r'*.egg-info')]
+
+
+def estimate_package_size(package):
+    """ 估计一个库占用的存储大小 """
+
+    # 将cache文件存储到临时目录中，避免重复获取网页
+    def get_size(package):
+        r = requests.get(f'https://pypi.org/project/{package}/#files')
+        if r.status_code == 404:
+            return '(0 MB'  # 找不到的包默认按0MB计算
+        else:
+            return r.text
+
+    s = cache_file(package + '.pypi', lambda: get_size(package))
+    # 找出所有包大小，计算平均值作为这个包大小的预估
+    # 注意，这里进位是x1000，不是x1024
+    v = mean(list(map(parse_size, re.findall(r'\((\d+(?:\.\d+)?\s*\wB(?:ytes)?)', s))) or [0])
+    return v
+
+
+def estimate_pip_packages(*, print_mode=False):
+    """ 检查pip list中包的大小，从大到小排序
+
+    :param print_mode:
+        0，不输出，只返回运算结果，[(package_name, package_size), ...]
+        1，输出最后的美化过的运算表格
+        2，输出中间计算过程
+    """
+
+    def printf(*args, **kwargs):
+        # dm表示mode增量
+        if print_mode > 1:
+            print(*args, **kwargs)
+
+    packages = get_installed_packages()
+    package_sizes = []
+    for package_name in packages:
+        package_size = estimate_package_size(package_name)
+        package_sizes.append((package_name, package_size))
+        printf(f"{package_name}: {human_readable_size(package_size)}")
+
+    package_sizes.sort(key=lambda x: (-x[1], x[0]))
+    if print_mode > 0:
+        if print_mode > 1: print('- ' * 20)
+        for package_name, package_size in package_sizes:
+            print(f"{package_name}: {human_readable_size(package_size)}")
+    return package_sizes
+
+
+class ProgressBar:
+    """ 对运行可能需要较长时间的任务，添加进度条显示
+
+    # 示例用法
+    with ProgressBar(100) as pb:
+        for i in range(100):
+            time.sleep(0.1)  # 模拟耗时工作
+            pb.progress = i + 1  # 更新进度
+    """
+
+    def __init__(self, total):
+        self.total = total  # 总进度
+        self.progress = 0  # 当前进度
+        self.stop_flag = False  # 停止标志
+
+    def __enter__(self):
+        # 启动进度显示线程
+        self.progress_thread = Thread(target=self.display_progress)
+        self.progress_thread.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # 强制将进度设置为100%
+        self.progress = self.total
+        # 停止进度显示线程
+        self.stop_flag = True
+        self.progress_thread.join()
+
+    def display_progress(self):
+        with tqdm(total=self.total) as pbar:
+            while not self.stop_flag:
+                pbar.n = self.progress
+                pbar.refresh()
+                time.sleep(1)
+            pbar.n = self.progress
+            pbar.refresh()
+
+
+class BitMaskTool:
+    """ 二进制位掩码工具
+
+    概念术语
+        bitval，每一个位上的具体取值，0或1
+        bitsum，所有位上的取值的和，即二进制数的十进制表示
+    """
+
+    def __init__(self, bit_names=None, bitsum_counter=None):
+        """ 初始化 BitMaskTool 对象
+
+        :param list bit_names: 每一位功能开启时，显示的标签名。未输入时，填充0,1,2,3...注意总数，要按域宽对齐
+        :param dict/list bitsum_counter: 各种值出现的次数，可以是一个字典或者一个包含出现次数的列表
+        """
+        # 1 每一位功能开启时，显示的标签名。未输入时，填充0,1,2,3...注意总数，要按域宽对齐
+        if bit_names is None:
+            bit_names = list(aligned_range(len(bit_names)))
+        self.bit_names = bit_names
+        # 2 各种值出现的次数
+        if isinstance(bitsum_counter, (list, tuple)):
+            bitsum_counter = Counter(bitsum_counter)
+        self.bitsum_counter = bitsum_counter or {}
+
+    def get_bitsum_names(self, bitsum):
+        """ 从bitsum得到names的拼接
+
+        >> get_bitsum_names(3)
+        '语义定位,图表'
+        """
+        if not isinstance(bitsum, int):
+            try:
+                bitsum = int(bitsum)
+            except ValueError:
+                bitsum = 0
+
+        tags = []
+        for i, k in enumerate(self.bit_names):
+            if (1 << i) & bitsum:
+                tags.append(k)
+        return ','.join(tags)
+
+    def count_bitsum_relations(self, target_bitsum, relation='='):
+        """ 计算特定关系的 bitsum 数量
+
+        :param int target_bitsum: 目标 bitsum
+        :param str relation: 关系类型，可以是 '=', '⊂', '⊃'
+            假设bitval对应的bit_names为n1,n2,n3,n4。
+            那么bitsum相当于是bitval的一个集合
+            比如a={n1,n3,n4}，b={n1,n3}，因为a完全包含b，所以认为a⊃b，或者a⊋b、b⊂a、b⊊a
+        :return int: 符合条件的 bitsum 数量
+        """
+        count = 0
+        if relation == '=':
+            # 直接计算等于 target_bitsum 的数量
+            count = self.bitsum_counter.get(target_bitsum, 0)
+        elif relation == '⊂':
+            # 计算所有被 target_bitsum 包含的 bitsum 的数量
+            for bitsum, num in self.bitsum_counter.items():
+                if bitsum and bitsum & target_bitsum == bitsum:
+                    count += num
+        elif relation == '⊃':
+            # 计算所有包含 target_bitsum 的 bitsum 的数量
+            for bitsum, num in self.bitsum_counter.items():
+                if bitsum & target_bitsum == target_bitsum:
+                    count += num
+        return count
+
+    def check_bitflag(self, max_bitsum_len=None, reletion='=',
+                      filter_zero=False, sort_by=None, *,
+                      min_bitsum_len=0):
+        """ 检查并返回 bitsum 关系的 DataFrame
+
+        :param int max_bitsum_len: 最大 bitsum 长度
+        :param str reletion: 关系类型，可以是 '=', '⊂', '⊃'
+            支持输入多个字符，表示要同时计算多种关系
+        :param bool filter_zero: 是否过滤掉零值
+        :param None|str sort_by: 排序字段
+            None, 默认排序
+            count, 按照数量从大到小排序
+            bitsum, 按照 bitsum 从小到大排序
+        :param int min_bitsum_len: 最小 bitsum 长度
+        :return: 包含 bitsum 关系的 DataFrame
+        """
+        from itertools import combinations
+
+        total = sum(self.bitsum_counter.values())
+        rows, columns = [], ['类型', '名称', '百分比.次数']
+        rows.append([-1, '总计', total])
+
+        if max_bitsum_len is None:
+            max_bitsum_len = len(self.bit_names)
+
+        bitvals = [(1 << i) for i in range(len(self.bit_names))]
+        for m in range(min_bitsum_len, max_bitsum_len + 1):
+            for comb in combinations(bitvals, m):
+                bitsum = sum(comb)
+                count = self.count_bitsum_relations(bitsum, relation=reletion)
+                if filter_zero and count == 0:
+                    continue
+                rows.append([f'{reletion}{bitsum}',
+                             self.get_bitsum_names(bitsum),
+                             count])
+
+        if sort_by == 'count':
+            rows.sort(key=lambda x: x[2], reverse=True)
+        elif sort_by == 'bitsum':
+            rows.sort(key=lambda x: int(x[0][1:]) if isinstance(x[0], str) else x[0])
+
+        df = pd.DataFrame.from_records(rows, columns=columns)
+        df['百分比.次数'] = percentage_and_value(df['百分比.次数'], 2, total=total)
+        return df
+
+    def report(self):
+        """ 生成统计报告 """
+        html_content = []
+
+        html_content.append('<h1>1 包含每一位bitval特征的数量</h1>')
+        df1 = self.check_bitflag(1, '⊃')
+        html_content.append(df1.to_html())
+
+        html_content.append('<h1>2 每一种具体bitsum组合的数量</h1>')
+        df2 = self.check_bitflag(reletion='=', filter_zero=True, sort_by='bitsum')
+        html_content.append(df2.to_html())
+
+        return '\n'.join(html_content)
+
+
+def loguru_setup_jsonl_logfile(logger, log_dir, rotation_size="10 MB"):
+    """
+    给loguru的日志器添加导出文件的功能，使用jsonl格式
+
+    :param logger: 日志记录器，一般是from loguru import logger的logger
+    :param log_dir: 存储日志的目录，因为有多个文件，这里要输入的是所在的目录
+    :param rotation_size: 文件多大后分割
+    :return:
+    """
+    from datetime import datetime
+
+    os.makedirs(log_dir, exist_ok=True)  # 自动创建日志目录
+
+    # 日志文件名匹配的正则表达式，格式为 年月日_时分秒.log
+    log_filename_pattern = re.compile(r"(\d{8}_\d{6})\.jsonl")
+
+    # 找到最新的日志文件
+    def find_latest_log_file(log_dir):
+        log_files = []
+        for file in os.listdir(log_dir):
+            if log_filename_pattern.match(file):
+                log_files.append(file)
+
+        if log_files:
+            # 根据时间排序，选择最新的日志文件
+            log_files.sort(reverse=True)
+            return os.path.join(log_dir, log_files[0])
+        return None
+
+    # 检查是否有未写满的日志文件
+    latest_log_file = find_latest_log_file(log_dir)
+
+    if latest_log_file:
+        log_path = latest_log_file
+    else:
+        # 生成新的日志文件名
+        log_filename = datetime.now().strftime("%Y%m%d_%H%M%S") + ".jsonl"
+        log_path = os.path.join(log_dir, log_filename)
+
+    # 配置 logger，写入日志文件，设置旋转条件，使用 JSON 序列化
+    logger.add(log_path, rotation=rotation_size, serialize=True)
+
+    # 输出初始化成功信息
+    logger.info(f"日志系统已初始化，日志文件路径：{log_path}")

pyxllib/prog/specialist/bc.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2020/06/01 18:13
+
+import copy
+
+from pyxllib.prog.pupil import dprint, prettifystr
+from pyxllib.prog.specialist.browser import Explorer
+from pyxllib.algo.pupil import intersection_split
+from pyxllib.file.specialist import File, Dir, filesmatch, get_encoding, XlPath
+
+
+# 需要使用的第三方软件
+# BCompare.exe， bcompare函数要用
+
+class BCompare(Explorer):
+    def __init__(self, app='bcomp', shell=False):
+        """
+        240512周日20:06，本来写的是BCompare，但是友鑫mac电脑上发现似乎有问题，所以改成bcomp，这种在windows上也能用
+        """
+        super().__init__(app, shell)
+
+    @classmethod
+    def to_bcompare_files(cls, *args, files=None):
+        """ 这个需要一次性获得所有的数据，才适合分析整体上要怎么获取对应的多个文件
+
+        :param files: 每个arg对应的文件名，默认按 'left'、'right', 'base' 来生成
+            也可以输入一个list[str]，表示多个args依次对应的文件名
+            filename的长度可以跟args不一致，多的不用，少的自动生成
+        """
+        # 1 如果oldfile和newfile都是dict、set、list、tuple，则使用特殊方法文本化
+        #   如果两个都是list，不应该提取key后比较，所以限制第1个类型必须是dict或set，然后第二个类型可以适当放宽条件
+        # if not oldfile: oldfile = str(oldfile)
+        if len(args) > 1 and isinstance(args[0], (dict, set)) and isinstance(args[1], (dict, set, list, tuple)):
+            args = copy.copy(list(args))
+            t = [prettifystr(li) for li in intersection_split(args[0], args[1])]
+            args[0] = f'【共有部分】，{t[0]}\n\n【独有部分】，{t[1]}'
+            args[1] = f'【共有部分】，{t[2]}\n\n【独有部分】，{t[3]}'
+
+        # 2 参数对齐
+        if not isinstance(files, (list, tuple)):
+            files = [files]
+        if len(files) < len(args):
+            files += [None] * (len(args) - len(files))
+        ref_names = ['left', 'right', 'base']
+
+        # 3 将每个参数转成一个文件
+        new_args = []
+        default_suffix = None
+        for i, arg in enumerate(args):
+            f = XlPath.safe_init(arg)
+            if f is not None and f.is_file():  # 是文件对象，且存在
+                new_args.append(f)
+                if not default_suffix:
+                    default_suffix = f.suffix
+            # elif isinstance(f, File):  # 文本内容也可能生成合法的伪路径，既然找不到还是统一按字符串对比差异好
+            #     # 是文件对象，但不存在 -> 报错
+            #     raise FileNotFoundError(f'{f}')
+            else:  # 不是文件对象，要转存到文件
+                if not files[i]:  # 没有设置文件名则生成一个
+                    files[i] = XlPath.init(ref_names[i], XlPath.tempdir(), suffix=default_suffix)
+                else:
+                    files[i] = XlPath(files[i])
+                files[i].write_text(str(arg))
+                new_args.append(files[i])
+
+        return new_args
+
+    def __call__(self, *args, wait=True, files=None, sameoff=False, **kwargs):
+        r"""
+        :param wait:
+            一般调用bcompare的时候，默认值wait=True，python是打开一个子进程并等待bcompare软件关闭后，才继续执行后续代码。
+            如果你的业务场景并不需要等待bcompare关闭后执行后续python代码，可以设为wait=False，不等待。
+        :param sameoff: 如果设为True，则会判断内容，两份内容如果相同则不打开bc
+            这个参数一定程度会影响性能，非必要的时候不要开。
+            或者在外部的时候，更清楚数据情况，可以在外部判断内容不重复再跑bcompare函数
+            这个目前的实现策略，是读取文件重新判断的，会有性能开销，默认关闭该功能
+        :return: 程序返回被修改的oldfile内容
+            注意如果没有修改，或者wait=False，会返回原始值
+        """
+        files = self.to_bcompare_files(*args, files=files)
+
+        if sameoff and len(files) > 1:
+            if files[0].read_auto() == files[1].read_auto():
+                return
+        super().__call__(*([str(f) for f in files]), wait=wait, **kwargs)
+        # bc软件操作中可能会修改原文内容，所以这里需要重新读取，不能用前面算过的结果
+        return XlPath(files[0]).read_auto()
+
+
+bcompare = BCompare()  # nowatch: 调试阶段，不需要自动watch的变量
+
+
+def modify_file(file, func, *, outfile=None, file_mode=None, debug=0):
+    """ 对单个文件就行优化的功能函数
+
+    这样一些底层函数功能可以写成数据级的接口，然后由这个函数负责文件的读写操作，并且支持debug比较前后内容差异
+
+    :param outfile: 默认是对file原地操作，如果使用该参数，则将处理后的内容写入outfile文件
+    :param file_mode: 指定文件读取类型格式，例如'.json'是json文件，读取为字典
+    :param debug: 这个功能可以对照refine分级轮理解
+        无outfile参数时，原地操作
+            0，【直接原地操作】关闭调试，直接运行 （根据outfile=None选择原地操作，或者指定生成新文件）
+            1，【进行审核】打开BC比较差异，左边原始内容，右边参考内容  （打开前后差异内容对比）
+            -1，【先斩后奏】介于完全不调试和全部人工检查之间，特殊的差异比较。左边放原始文件修改后的结果，右边对照原内容。
+        有outfile参数时
+            0 | False，直接生成目标文件，如果outfile已存在会被覆盖
+            1 | True，直接生成目标文件，但是会弹出bc比较前后内容差异 （相同内容不会弹出）
+    """
+    infile = File(file)
+    enc = get_encoding(infile.read(mode='b'))
+    data = infile.read(mode=file_mode, encoding=enc)
+    origin_content = str(data)
+    new_data = func(data)
+
+    isdiff = origin_content != str(new_data)
+    if outfile is None:  # 原地操作
+        if isdiff:  # 内容不同才会有相关debug功能，否则静默跳过就好
+            if debug == 0:
+                infile.write(new_data, mode=file_mode)  # 直接处理
+            elif debug == 1:
+                temp_file = File('refine_content', Dir.TEMP, suffix=infile.suffix).write(new_data)
+                bcompare(infile, temp_file)  # 使用beyond compare软件打开对比查看
+            elif debug == -1:
+                temp_file = File('origin_content', Dir.TEMP, suffix=infile.suffix)
+                infile.copy(temp_file)
+                infile.write(new_data, mode=file_mode, encoding=enc)  # 把原文件内容替换了
+                bcompare(infile, temp_file)  # 然后显示与旧内容进行对比
+            else:
+                raise ValueError(f'{debug}')
+    else:
+        outfile = File(outfile)
+        outfile.write(new_data, mode=file_mode, encoding=enc)  # 直接处理
+        if debug and isdiff:
+            bcompare(infile, outfile)
+
+    return isdiff
+
+
+class PairContent:
+    """ 配对文本类，主要用于bc差异比较 """
+
+    def __init__(self, left_file_name=None, right_file_name=None):
+        self.left_file = File(left_file_name) if left_file_name else left_file_name
+        self.right_file = File(right_file_name) if right_file_name else right_file_name
+        self.left, self.right = [], []
+
+    def add(self, lt, rt=None):
+        """ rt不加，默认本轮内容是同lt """
+        lt = str(lt)
+        self.left.append(lt)
+        rt = lt if rt is None else str(rt)
+        self.right.append(rt)
+
+    def bcompare(self, **kwargs):
+        left, right = '\n'.join(self.left), '\n'.join(self.right)
+        if self.left_file is not None:
+            left = self.left_file.write(left)
+        if self.right_file is not None:
+            right = self.right_file.write(right)
+        bcompare(left, right, **kwargs)
+
+
+def filetext_replace(files, func, *,
+                     count=-1, start=1, bc=False, write=False, if_exists=None):
+    r"""遍历目录下的文本文件进行批量处理的功能函数
+
+    :param files: 文件匹配规则，详见filesmatch用法
+    :param func: 通用文本处理函数
+    :param count: 匹配到count个文件后结束，防止满足条件的文件太多，程序会跑死
+    :param start: 从编号几的文件开始查找，一般在遇到意外调试的时候使用
+    :param bc: 使用beyond compare软件
+        注意bc的优先级比write高，如果bc和write同时为True，则会开bc，但并不会执行write
+    :param write: 是否原地修改文件内容进行保存
+    :param if_exists: 是否进行备份，详见writefile里的参数文件
+    :return: 满足条件的文件清单
+    """
+    ls = []
+    total = 0
+    for f in filesmatch(files):
+        # if 'A4-Exam' in f:
+        #     continue
+        total += 1
+        if total < start:
+            continue
+        s0 = File(f).read()
+        s1 = func(s0)
+        if s0 != s1:
+            match = len(ls) + 1
+            dprint(f, total, match)
+            if bc:
+                bcompare(f, s1)
+            elif write:  # 如果开了bc，程序是绝对不会自动写入的
+                File(f).write(s1, if_exists=if_exists)
+            ls.append(f)
+            if len(ls) == count:
+                break
+
+    match_num = len(ls)
+    dprint(total, match_num)
+    return ls