本文由 大侠(AhcaoZhu)原创，转载请声明。
链接: https://blog.csdn.net/Ahcao2008

🧊摘要

• 全文介绍python的 setuptools 模块（一个功能齐全、积极维护且稳定的库，旨在方便打包Python项目）、函数、类及类的方法和属性。
• 它通过代码抓取并经AI智能翻译和人工校对。
• 是一部不可多得的权威字典类工具书。它是系列集的一部分。后续陆续发布、敬请关注。【原创：AhcaoZhu大侠】

🧊模块图

setuptools
	setuptools._distutils
		◆distutils.util
		◆distutils.dist
		◆distutils.cmd
		setuptools._distutils.archive_util
			setuptools._distutils.log
	setuptools._deprecation_warning
	setuptools.version
		◆pkg_resources
	setuptools.monkey
	setuptools.extension
	setuptools.extern
		setuptools._vendor.packaging
			setuptools._vendor.packaging.__about__
			setuptools.extern.packaging._structures
			setuptools._vendor.packaging._manylinux
			setuptools._vendor.packaging._musllinux
			setuptools.extern.packaging.tags
			setuptools.extern.packaging.utils
			setuptools.extern.packaging.specifiers
		setuptools._vendor.ordered_set
		setuptools._vendor.more_itertools
			setuptools._vendor.more_itertools.recipes
			setuptools._vendor.more_itertools.more
	setuptools._vendor
	setuptools.command
	setuptools.windows_support
	setuptools.config
	setuptools.dist
		setuptools.extern.packaging.version
	setuptools.py34compat
	setuptools._imp
	setuptools.depends
		◆marshal
		◆dis
	setuptools.logging
	setuptools.msvc
		◆subprocess
		◆winreg

🧊类关系图

◆object
	◆BaseException
		◆Exception
			◆ValueError
				setuptools._vendor.more_itertools.more.UnequalIterablesError
				setuptools.extern.packaging.specifiers.InvalidSpecifier
				setuptools.extern.packaging.utils.InvalidSdistFilename
				setuptools.extern.packaging.utils.InvalidWheelFilename
				setuptools.extern.packaging.version.InvalidVersion
			◆Warning
				setuptools._deprecation_warning.SetuptoolsDeprecationWarning
					setuptools.dist.DistDeprecationWarning
		setuptools._vendor.more_itertools.more.AbortThread
	◆collections.abc.Container
		◆collections.abc.Iterable
			◆collections.abc.Reversible
				◆collections.abc.Sequence
					◆collections.abc.Set
						◆collections.abc.MutableSet
							setuptools._vendor.ordered_set.OrderedSet
					setuptools._vendor.more_itertools.more.SequenceView
					setuptools._vendor.more_itertools.more.numeric_range
	◆distutils.cmd.Command
		setuptools.Command
	◆distutils.dist.Distribution
		setuptools.dist.Distribution
	◆distutils.extension.Extension
		setuptools.extension.Extension
			setuptools.extension.Library
	setuptools.PackageFinder
		setuptools.PEP420PackageFinder
	setuptools._distutils.log.Log
	setuptools._vendor.more_itertools.more.bucket
	setuptools._vendor.more_itertools.more.callback_iter
	setuptools._vendor.more_itertools.more.countable
	setuptools._vendor.more_itertools.more.islice_extended
	setuptools._vendor.more_itertools.more.peekable
	setuptools._vendor.more_itertools.more.run_length
	setuptools._vendor.more_itertools.more.seekable
	setuptools._vendor.more_itertools.more.time_limited
	setuptools._vendor.packaging._manylinux._ELFFileHeader
	setuptools.config.ConfigHandler
		setuptools.config.ConfigMetadataHandler
		setuptools.config.ConfigOptionsHandler
	setuptools.config.StaticModule
	setuptools.depends.Require
	setuptools.extern.VendorImporter
	setuptools.extern.packaging._structures.InfinityType
	setuptools.extern.packaging._structures.NegativeInfinityType
	setuptools.extern.packaging.specifiers.BaseSpecifier
		setuptools.extern.packaging.specifiers.SpecifierSet
		setuptools.extern.packaging.specifiers._IndividualSpecifier
			setuptools.extern.packaging.specifiers.LegacySpecifier
			setuptools.extern.packaging.specifiers.Specifier
	setuptools.extern.packaging.tags.Tag
	setuptools.extern.packaging.version._BaseVersion
		setuptools.extern.packaging.version.LegacyVersion
		setuptools.extern.packaging.version.Version
	setuptools.msvc.EnvironmentInfo
	setuptools.msvc.PlatformInfo
	setuptools.msvc.RegistryInfo
	setuptools.msvc.SystemInfo
	◆str
		setuptools.sic
	◆tuple
		setuptools._vendor.packaging._manylinux._GLibCVersion
		setuptools._vendor.packaging._musllinux._MuslVersion
		setuptools.extern.packaging.version._Version

🧊模块全展开

☘️【setuptools】

setuptools, fullname=setuptools, file=setuptools_init_.py

针对大型或复杂发行版的'distutils'扩展

🔵统计

序号	类别	数量
4	str	6
6	list	2
8	dict	1
9	module	22
10	class	10
11	function	6
13	residual	5
14	system	11
15	private	8
16	all	52

🔵常量

🔵模块

🌿1 functools

functools, fullname=functools, file=functools.py

🌿2 os

os, fullname=os, file=os.py

🌿3 re

re, fullname=re, file=re.py

🌿4 setuptools._distutils

_distutils, fullname=setuptools.distutils, file=setuptools_distutils_init.py

Python模块发布实用程序的主包。
通常从distutils的设置脚本中使用
   from distutils.core import setup
   setup (...)

🌿5 _distutils_hack

_distutils_hack, fullname=_distutils_hack, file=distutils_hack_init.py

🌿6 setuptools._distutils

_distutils, fullname=setuptools.distutils, file=setuptools_distutils_init.py

🌿7 setuptools._deprecation_warning

_deprecation_warning, fullname=setuptools._deprecation_warning, file=setuptools_deprecation_warning.py

🌿8 setuptools.version

version, fullname=setuptools.version, file=setuptools\version.py

🌿9 setuptools

setuptools, fullname=setuptools, file=setuptools_init_.py

针对大型或复杂发行版的'distutils'扩展

🌿10 setuptools.monkey

monkey, fullname=setuptools.monkey, file=setuptools\monkey.py

distutils 的Monkey补丁。

🌿11 setuptools.extension

extension, fullname=setuptools.extension, file=setuptools\extension.py

🌿12 setuptools.extern

extern, fullname=setuptools.extern, file=setuptools\extern_init_.py

🌿13 setuptools._vendor

_vendor, fullname=setuptools.vendor, file=setuptools_vendor_init.py

🌿14 setuptools.command

command, fullname=setuptools.command, file=setuptools\command_init_.py

🌿15 setuptools.windows_support

windows_support, fullname=setuptools.windows_support, file=setuptools\windows_support.py

🌿16 setuptools.config

config, fullname=setuptools.config, file=setuptools\config.py

🌿17 setuptools.dist

dist, fullname=setuptools.dist, file=setuptools\dist.py

🌿18 setuptools.py34compat

py34compat, fullname=setuptools.py34compat, file=setuptools\py34compat.py

🌿19 setuptools._imp

_imp, fullname=setuptools._imp, file=setuptools_imp.py

重新实现查找模块并从已弃用的imp模块获取冻结对象。

🌿20 setuptools.depends

depends, fullname=setuptools.depends, file=setuptools\depends.py

🌿21 setuptools.logging

logging, fullname=setuptools.logging, file=setuptools\logging.py

🌿22 setuptools.msvc

msvc, fullname=setuptools.msvc, file=setuptools\msvc.py

改进了对Microsoft Visual c++编译器的支持。
已知支持的编译器:
--------------------------
Microsoft Visual C++ 9.0:
    Microsoft Visual C++ Compiler for Python 2.7 (x86, amd64)
    Microsoft Windows SDK 6.1 (x86, x64, ia64)
    Microsoft Windows SDK 7.0 (x86, x64, ia64)

Microsoft Visual C++ 10.0:
    Microsoft Windows SDK 7.1 (x86, x64, ia64)

Microsoft Visual C++ 14.X:
    Microsoft Visual C++ Build Tools 2015 (x86, x64, arm)
    Microsoft Visual Studio Build Tools 2017 (x86, x64, arm, arm64)
    Microsoft Visual Studio Build Tools 2019 (x86, x64, arm, arm64)
这也可能支持与兼容的Visual Studio版本一起发布的编译器。

🔵函数

🌿23 fnmatchcase(name, pat)

fnmatchcase(name, pat), module=fnmatch, line:64 at fnmatch.py

测试FILENAME是否与PATTERN匹配，包括大小写。
这是fnmatch()的一个版本，它不会对其参数进行大小写规范化。

🌿24 convert_path(pathname)

convert_path(pathname), module=distutils.util, line:166 at site-packages\setuptools_distutils\util.py

返回'pathname'作为本机文件系统上的名称，即在'/'上分割它，然后使用当前目录分隔符将其重新组合在一起。
之所以需要，是因为设置脚本中的文件名总是以Unix风格提供的，并且在我们可以在文件系统中实际使用它们之前必须转换为本地约定。
如果'pathname'以斜杠开始或结束，在非unix系统上引发ValueError。

🌿25 _install_setup_requires(attrs)

install_setup_requires(attrs), module=setuptools, line:123 at site-packages\setuptools_init.py

🌿26 setup(**attrs)

setup(**attrs), module=setuptools, line:151 at site-packages\setuptools_init_.py

通往Distutils的门户:以高度灵活和用户驱动的方式完成设置脚本需要做的所有事情。
简单地说:创建一个Distribution实例;查找和解析配置文件;解析命令行;
运行其中找到的每个Distutils命令，这些命令由提供给'setup()'的选项(作为关键字参数)在配置文件和命令行中定制。
Distribution实例可能是通过'distclass'关键字参数提供给'setup'的一个类的实例;
如果没有提供这样的类，那么将实例化Distribution类(在dist.py中)。
'setup'的所有其他参数('cmdclass'除外)用于设置Distribution实例的属性。
如果提供了'cmdclass'参数，则是一个将命令名称映射到命令类的字典。
在命令行上遇到的每个命令都将被转换为命令类，然后实例化;
在'cmdclass'中找到的任何类都用于代替默认值，即(对于命令'foo_bar')模块'distutils.command.foo bar'中的类'foo_bar'。
命令类必须提供一个'user_options'属性，该属性是'distutils‘的选项说明符列表。花哨的getopt”。
当前命令和下一个命令之间的命令行选项用于设置当前命令对象的属性。
当整个命令行被成功解析后，依次在每个命令对象上调用'run()'方法。
此方法将完全由Distribution对象(由于其构造函数，每个命令对象都有对其的引用)和特定于命令的选项驱动，这些选项成为每个命令对象的属性。

🌿27 _find_all_simple(path)

find_all_simple(path), module=setuptools, line:215 at site-packages\setuptools_init.py

查找'path'下的所有文件

🌿28 findall(dir=‘.’)

findall(dir=‘.’), module=setuptools, line:227 at site-packages\setuptools_init_.py

查找'dir'下的所有文件并返回完整文件名的列表。
除非dir是'.'，返回带有dir前缀的完整文件名。

🔵类

🌿29 distutils.errors.DistutilsOptionError

DistutilsOptionError, distutils.errors.DistutilsOptionError, module=distutils.errors, line:0 at

命令选项中的语法/语义错误，例如使用相互冲突的选项，或不一致的选项，拼写错误的值等。
源自安装脚本、命令行、配置文件或其他任何东西的选项值之间没有区别，但如果我们“知道”源自安装脚本的内容，我们将引发DistutilsSetupError。

🌿30 setuptools._deprecation_warning.SetuptoolsDeprecationWarning

SetuptoolsDeprecationWarning, setuptools._deprecation_warning.SetuptoolsDeprecationWarning, module=setuptools._deprecation_warning, line:1 at site-packages\setuptools_deprecation_warning.py

``setuptools``中警告弃用的基类。这个类不是从``DeprecationWarning``派生的，因此默认情况下是可见的。

🌿31 setuptools.extension.Extension

Extension, setuptools.extension.Extension, module=setuptools.extension, line:30 at site-packages\setuptools\extension.py

使用'.c'文件代替'.c'文件的扩展名'.pyx'的文件

🌿32 setuptools.dist.Distribution

Distribution, setuptools.dist.Distribution, module=setuptools.dist, line:371 at site-packages\setuptools\dist.py

支持测试和包数据的发行版。
这是'distutils.dist‘的增强版本。Distribution'有效地将以下新的可选关键字参数添加到'setup()':
    'install_requires' -一个字符串或字符串序列，指定安装发行版时需要的项目版本，格式为'pkg_resources.require()'。
                        它们将在安装包时自动安装。如果你想使用PyPI中不可用的包，或者想给你的用户一个替代的下载位置，
                        你可以在你的项目的“设置”的“[easy install]”部分添加“查找链接”选项。
                        然后，setuptools将扫描列出的网页，寻找满足要求的链接。
    'extras_require' -一个字典，将可选的'extras‘的名称映射到使用这些extras所产生的额外要求。例如:
                        extras_require = dict(reST = ["docutils>=0.3"， "reSTedit"])
                        表明发行版可以选择性地提供名为"reST"的额外功能，但它只能在安装了docutils和reSTedit的情况下使用。
                        如果用户使用EasyInstall安装您的包并请求您的一个附加组件，则如果需要，将安装相应的附加需求。
    'test_suite' -为'test'命令运行的测试套件的名称。
                        如果用户运行'python setup.py test'，该包将被安装，并且指定的测试套件将运行。
                        格式与在'unittest.py'命令行中使用的格式相同。也就是说，它是要导入并调用以生成测试套件的对象的带点名称。
    'package_data' -一个将包名称映射到文件名或globs列表的字典，用于查找命名包中包含的数据文件。
                    如果字典在(空字符串)下列出了文件名或globs，那么除了特定包的任何名称外，还将在每个包中搜索这些名称。
                    使用这些名称/globs找到的数据文件将与包一起安装在与包相同的位置。
                    请注意，只要使用'/'作为路径分隔符，就允许globs引用非包子目录的内容。(Globs在运行时自动转换为特定于平台的路径。)
    除了这些新的关键字，这个类还有几个新的方法来操作分布的内容。
    例如，'include()'和'exclude()'方法可以被认为是就地添加和减去命令，用于从发行版中添加或删除包、模块、扩展等。

method

1 exclude(self, **attrs)

kind=method class=Distribution objtype=function line:1002 at …\lib\site-packages\setuptools\dist.py

从发行版中删除以关键字参数命名的项。
例如，'dist.exclude(py_modules=["x"])'将从发行版的'py_modules'属性中删除'x'。
排除包使用'exclude package()'方法，因此包中包含的所有包、模块和扩展也被排除在外。
目前，此方法仅支持从列表或元组的属性中排除。
如果你需要在这个类或子类中添加对排除其他属性的支持，你可以添加一个'_exclude_X'方法，其中'X'是属性的名称。
该方法将被调用，并将值传递给'exclude()'。
因此，'dist.exclude(foo={"bar":"baz"})'将尝试调用'dist.exclude_foo({"bar":"baz"})'，然后它可以处理任何需要的特殊排除逻辑。

2 exclude_package(self, package)

kind=method class=Distribution objtype=function line:936 at …\lib\site-packages\setuptools\dist.py

删除命名包中的包、模块和扩展

3 fetch_build_egg(self, req)

kind=method class=Distribution objtype=function line:879 at …\lib\site-packages\setuptools\dist.py

取一个建造所需的egg

4 fetch_build_eggs(self, requires)

kind=method class=Distribution objtype=function line:810 at …\lib\site-packages\setuptools\dist.py

解决安装前的要求

5 finalize_options(self)

kind=method class=Distribution objtype=function line:821 at …\lib\site-packages\setuptools\dist.py

允许插件对发行版应用任意操作。
每个钩子可以选择定义一个“顺序”来影响执行的顺序。较小的数字优先，默认值为0。

6 get_cmdline_options(self)

kind=method class=Distribution objtype=function line:1059 at …\lib\site-packages\setuptools\dist.py

返回所有命令行选项的'{cmd: {opt:val}}'映射。
选项名称都很长，但不包括前导'-'，并且包含破折号而不是下划线。
如果该选项不带参数(例如:'-quiet')，则'val'为'None'。
注意，配置文件提供的选项被有意排除在外。

7 get_command_class(self, command)

kind=method class=Distribution objtype=function line:885 at …\lib\site-packages\setuptools\dist.py

get_command_class() 的可插入版本

8 get_command_list(self)

kind=method class=Distribution objtype=function line:906 at …\lib\site-packages\setuptools\dist.py

9 get_egg_cache_dir(self)

kind=method class=Distribution objtype=function line:860 at …\lib\site-packages\setuptools\dist.py

10 handle_display_options(self, option_order)

kind=method class=Distribution objtype=function line:1117 at …\lib\site-packages\setuptools\dist.py

如果命令行上有任何非全局的"仅显示"选项(-help-commands或元数据显示选项)，则显示请求的信息并返回true;否则返回false。

11 has_contents_for(self, package)

kind=method class=Distribution objtype=function line:957 at …\lib\site-packages\setuptools\dist.py

如果'exclude package(package)'将执行某些操作，则返回true

12 include(self, **attrs)

kind=method class=Distribution objtype=function line:914 at …\lib\site-packages\setuptools\dist.py

例如，'dist.include(py modules=["x"])'会将'x'添加到发行版的'py_modules'属性中，如果它还不存在的话。
目前，此方法仅支持包含列表或元组的属性。
如果你需要在这个或子类中添加对其他属性的添加支持，你可以添加一个' include X'方法，其中'X'是属性的名称。
该方法将被调用，并将值传递给'include()'。
因此，'dist.include(foo={"bar":"baz"})'将尝试调用'dist._include_foo({"bar":"baz"})'，然后它可以处理任何需要的特殊包含逻辑。

13 iter_distribution_names(self)

kind=method class=Distribution objtype=function line:1099 at …\lib\site-packages\setuptools\dist.py

生成发行版中的所有包、模块和扩展名

14 make_option_lowercase(self, opt, section)

kind=method class=Distribution objtype=function line:738 at …\lib\site-packages\setuptools\dist.py

15 parse_config_files(self, filenames=None, ignore_option_errors=False)

kind=method class=Distribution objtype=function line:797 at …\lib\site-packages\setuptools\dist.py

16 patch_missing_pkg_info(self, attrs)

kind=method class=Distribution objtype=function line:433 at …\lib\site-packages\setuptools\dist.py

17 print_commands(self)

kind=method class=Distribution objtype=function line:898 at …\lib\site-packages\setuptools\dist.py

18 warn_dash_deprecation(self, opt, section)

kind=method class=Distribution objtype=function line:706 at …\lib\site-packages\setuptools\dist.py

🌿33 setuptools.depends.Require

Require, setuptools.depends.Require, module=setuptools.depends, line:17 at site-packages\setuptools\depends.py

构建或安装发行版的先决条件

method

1 full_name(self)

kind=method class=Require objtype=function line:35 at …\lib\site-packages\setuptools\depends.py

返回完整的包/发行版名称，w/version

2 get_version(self, paths=None, default=“unknown”)

kind=method class=Require objtype=function line:46 at …\lib\site-packages\setuptools\depends.py

获取已安装模块的版本号，'None'或'default'。
如果未找到，则返回'None'。
如果找到，返回提取的版本属性，如果没有指定版本属性，则返回'default'，或者在不导入模块的情况下无法确定值。
版本根据需求的版本格式(如果有的话)进行格式化，除非它是'None'或提供的'default'。

3 is_current(self, paths=None)

kind=method class=Require objtype=function line:77 at …\lib\site-packages\setuptools\depends.py

如果'paths'上存在最新的依赖项，则返回true

4 is_present(self, paths=None)

kind=method class=Require objtype=function line:73 at …\lib\site-packages\setuptools\depends.py

如果在'paths'上存在依赖，则返回true

5 version_ok(self, version)

kind=method class=Require objtype=function line:41 at …\lib\site-packages\setuptools\depends.py

“版本”是否足够最新?

🌿34 setuptools.PackageFinder

PackageFinder, setuptools.PackageFinder, module=setuptools, line:40 at site-packages\setuptools_init_.py

生成一个目录中所有Python包的列表

class method

1 find(cls, where=‘.’, exclude=(), include=(‘*’,))

kind=class method class=PackageFinder objtype=classmethod line:46 at …\lib\site-packages\setuptools_init_.py

将函数转换为类方法。

🌿35 setuptools.PEP420PackageFinder

PEP420PackageFinder, setuptools.PEP420PackageFinder, module=setuptools, line:113 at site-packages\setuptools_init_.py

🌿36 distutils.cmd.Command

Command, distutils.cmd.Command, module=distutils.cmd, line:0 at

用于定义命令类的抽象基类“工蜂”
对命令类的一个有用的类比是将它们视为具有称为“options”的局部变量的子例程。
这些选项在initialize_options()中被“声明”，在finalize_options()中被“定义”(给出它们的最终值，也就是“finalize”)，这两者都必须由每个命令类定义。
两者之间的区别是必要的，因为选项值可能来自外部世界(命令行，配置文件，…)
)，并且任何依赖于其他选项的选项必须在这些外部影响被处理后才计算——因此'finalize_options()'。
子例程的“主体”是'run()'方法，它根据其选项的值完成所有工作，该方法也必须由每个命令类实现。

data

1 sub_commands=[] kind:data type:list class:<class ‘distutils.cmd.Command’>

method

2 announce()

kind=method class=Command objtype=function

如果当前的详细级别大于或等于'level'，则将'msg'打印到标准输出。

3 copy_file()

kind=method class=Command objtype=function

根据详细、干运行和强制标志复制一个文件。
(前两者默认为Distribution对象中的任何内容，而对于未定义该对象的命令，后者默认为false。)

4 copy_tree()

kind=method class=Command objtype=function

根据详细、干运行和强制标志复制整个目录树。

5 debug_print()

kind=method class=Command objtype=function

如果全局DEBUG(从DISTUTILS_DEBUG环境变量中获取)标志为真，则打印'msg'到标准输出。

6 dump_options()

kind=method class=Command objtype=function

7 ensure_dirname()

kind=method class=Command objtype=function

8 ensure_filename()

kind=method class=Command objtype=function

确保'option'是现有文件的名称。

9 ensure_finalized()

kind=method class=Command objtype=function

10 ensure_string()

kind=method class=Command objtype=function

确保'option'是一个字符串;如果没有定义，将其设置为'default'。

11 ensure_string_list()

kind=method class=Command objtype=function

确保'option'是一个字符串列表。
如果'option'当前是一个字符串，我们在/，\s*/或/\s+/上拆分它，所以"foo bar baz"， "foo,bar,baz"和"foo,bar baz"都变成["foo"， "bar"， "baz"]。

12 execute()

kind=method class=Command objtype=function

13 finalize_options()

kind=method class=Command objtype=function

为该命令支持的所有选项设置最终值。
这总是越晚越好。在完成命令行或其他命令的任何选项赋值之后。
因此，这是编码选项依赖的地方:如果'foo'依赖于'bar'，那么只要'foo'仍然具有在'initialize_options()'中分配的相同值，
那么从'bar'设置'foo'是安全的。此方法必须由所有命令类实现。

14 get_command_name()

kind=method class=Command objtype=function

15 get_finalized_command()

kind=method class=Command objtype=function

围绕Distribution的'get_command_obj()'方法的包装:
为'command'查找(如果需要则创建，'create'为true)命令对象，调用其'ensure_finalize()'方法，并返回最终的命令对象。

16 get_sub_commands()

kind=method class=Command objtype=function

确定当前发行版中相关的子命令(例如，需要运行)。
这是基于'sub_commands'类属性:该列表中的每个元组可能包含一个方法，
我们调用该方法来确定是否需要为当前发行版运行子命令。
返回命令名称列表。

17 initialize_options()

kind=method class=Command objtype=function

为该命令支持的所有选项设置默认值。
请注意，这些默认值可能会被其他命令、设置脚本、配置文件或命令行覆盖。
因此，这里不是编写选项之间依赖关系的地方;通常，`initialize_options()`的实现只是一堆 "self.foo = None" 分配。此方法必须由所有命令类实现。

18 make_archive()

kind=method class=Command objtype=function

19 make_file()

kind=method class=Command objtype=function

处理一个或多个输入文件并生成一个输出文件的操作的'execute()'的特殊情况。
工作原理就像'execute()'，除了操作被跳过，如果'outfile'已经存在并且比'infiles'中列出的所有文件都更新，则打印不同的消息。
如果命令定义了 'self.force' ，如果为true，则无条件运行该命令-不进行时间戳检查。

20 mkpath()

kind=method class=Command objtype=function

21 move_file()

kind=method class=Command objtype=function

根据干运行标志移动文件。

22 reinitialize_command()

kind=method class=Command objtype=function

23 run()

kind=method class=Command objtype=function

命令存在的理由:执行它要执行的操作，由'initialize_options()'中初始化的选项控制，由其他命令、设置脚本、命令行和配置文件自定义，
并在'finalize_options()'中完成。所有终端输出和文件系统交互应该由'run()'完成。此方法必须由所有命令类实现。

24 run_command()

kind=method class=Command objtype=function

运行其他命令:使用Distribution的'run_command()'方法，该方法在必要时创建并完成命令对象，然后调用其'run()'方法。

25 set_undefined_options()

kind=method class=Command objtype=function

根据其他命令对象中相应的选项值设置任何“未定义”选项的值。这里的“未定义”是指 "is None"，
这是用于表示选项在'initialize_options()'和'finalize_options()'之间未被更改的约定。
通常从'finalize_options()'调用，用于依赖于其他命令而不是同一命令的其他选项的选项。
'src_cmd'是另一个将从中获取选项值的命令(必要时将为其创建一个命令对象);
其余的参数是'(src_option,dst_option)'元组，意思是"取'src_cmd'命令对象中的'src_option'的值，
并将其复制到当前命令对象中的'dst_option'。

26 spawn()

kind=method class=Command objtype=function

生成一个关于干运行标志的外部命令。

27 warn()

kind=method class=Command objtype=function

🌿37 setuptools.Command

Command, setuptools.Command, module=setuptools, line:164 at site-packages\setuptools_init_.py

用于定义命令类的抽象基类“工蜂”
对命令类的一个有用的类比是将它们视为具有称为“options”的局部变量的子例程。
这些选项在initialize_options()中被“声明”，在finalize_options()中被“定义”(给出它们的最终值，也就是“finalize”)，
这两者都必须由每个命令类定义。两者之间的区别是必要的，因为选项值可能来自外部世界(命令行，配置文件，…)
)，并且任何依赖于其他选项的选项必须在这些外部影响被处理后才计算——因此'finalize_options()'。
子例程的“主体”是'run()'方法，它根据其选项的值完成所有工作，该方法也必须由每个命令类实现。

data

1 command_consumes_arguments=False kind:data type:bool class:<class ‘setuptools.Command’>

method

2 ensure_string_list(self, option)

kind=method class=Command objtype=function line:188 at …\lib\site-packages\setuptools_init_.py

确保'option'是一个字符串列表。
如果'option'当前是一个字符串，我们在/，\s*/或/\s+/上拆分它，
所以"foo_bar_baz"， "foo,bar,baz"和"foo,bar baz"都变成["foo"， "bar"， "baz"]。

3 reinitialize_command(self, command, reinit_subcommands=0, **kw)

kind=method class=Command objtype=function line:209 at …\lib\site-packages\setuptools_init_.py

🌿38 setuptools.sic

sic, setuptools.sic, module=setuptools, line:239 at site-packages\setuptools_init_.py

按原样处理该字符串(https://en.wikipedia.org/wiki/Sic)

🔵私有或局部

39 _distutils <module ‘distutils’ (<_distutils_hack.DistutilsMetaFinder.spec_for_distutils..DistutilsLoader object at 0x00000195B76DEE88>)>
40 _distutils_hack <module ‘_distutils_hack’ from ‘…\lib\site-packages\_distutils_hack\init.py’>
41 _deprecation_warning <module ‘setuptools._deprecation_warning’ from ‘…\lib\site-packages\setuptools\_deprecation_warning.py’>
42 _vendor <module ‘setuptools._vendor’ from ‘…\lib\site-packages\setuptools\_vendor\init.py’>
43 _imp <module ‘setuptools._imp’ from ‘…\lib\site-packages\setuptools\_imp.py’>
44 _install_setup_requires <function _install_setup_requires at 0x00000195B76A24C8>
45 _Command <class ‘distutils.cmd.Command’>
46 _find_all_simple <function _find_all_simple at 0x00000195B8335948>

🔵剩余

47 loader <_frozen_importlib_external.SourceFileLoader object at 0x00000195B76A1148>
48 spec ModuleSpec(name=‘setuptools’, loader=<_frozen_importlib_external.SourceFileLoader object at 0x00000195B76A1148>, origin=‘…\lib\site-packages\setuptools\init.py’, submodule_search_locations=[‘…\lib\site-packages\setuptools’])
49 bootstrap_install_from
50 find_packages <bound method PackageFinder.find of <class ‘setuptools.PackageFinder’>>
51 find_namespace_packages <bound method PackageFinder.find of <class ‘setuptools.PEP420PackageFinder’>>

☘️【distutils.debug】

debug, fullname=distutils.debug, file=distutils\debug.py

☘️【distutils.errors】

errors, fullname=distutils.errors, file=distutils\errors.py

提供Distutils模块使用的异常。

☘️【distutils.fancy_getopt】

fancy_getopt, fullname=distutils.fancy_getopt, file=distutils\fancy_getopt.py

围绕标准getopt模块的包装器，提供一些附加功能。

☘️【distutils.dep_util】

dep_util, fullname=distutils.dep_util, file=distutils\dep_util.py

用于简单的、基于时间戳的文件和文件组依赖的实用函数;此外，函数完全基于这样的时间戳依赖性分析。

☘️【distutils.log】

log, fullname=distutils.log, file=distutils\log.py

一个类似于PEP 282的简单日志机制。

☘️【distutils.spawn】

spawn, fullname=distutils.spawn, file=distutils\spawn.py

提供'spawn()'函数，它是各种平台特定函数的前端，用于在子进程中启动另一个程序。还提供了'find executable()'来搜索给定可执行文件名的路径。

☘️【distutils.py35compat】

py35compat, fullname=distutils.py35compat, file=distutils\py35compat.py

☘️【distutils.util】

util, fullname=distutils.util, file=distutils\util.py

distutils。util杂项实用程序函数——任何不适合其他*util.py模块的函数。

☘️【distutils.dir_util】

dir_util, fullname=distutils.dir_util, file=distutils\dir_util.py

用于操作目录和目录树的实用函数。

☘️【distutils.file_util】

file_util, fullname=distutils.file_util, file=distutils\file_util.py

用于操作单个文件的实用程序函数。

☘️【setuptools._distutils.archive_util】

archive_util, fullname=setuptools._distutils.archive_util, file=setuptools_distutils\archive_util.py

archive_util用于创建存档文件(tarball、zip文件等)的实用函数。

🔵统计

序号	类别	数量
4	str	5
8	dict	2
9	module	4
10	class	1
11	function	8
12	builtin_function_or_method	1
13	residual	4
14	system	8
15	private	2
16	all	25

🔵常量

🌿dict

1 ARCHIVE_FORMATS {‘gztar’: (<function make_tarball at 0x00000195B774EB88>, [(‘compress’, ‘gzip’)], “gzip’ed tar-file”), ‘bztar’: (<functi…

🔵模块

🌿2 os

os, fullname=os, file=os.py

🌿3 sys

sys, fullname=sys, file=

🌿4 zipfile

zipfile, fullname=zipfile, file=zipfile.py

🌿5 setuptools._distutils.log

log, fullname=setuptools._distutils.log, file=setuptools_distutils\log.py

🔵函数

🌿6 spawn(cmd, search_path=1, verbose=0, dry_run=0, env=None)

spawn(cmd, search_path=1, verbose=0, dry_run=0, env=None), module=distutils.spawn, line:18 at site-packages\setuptools_distutils\spawn.py

在新进程中运行另一个程序，指定为命令列表'cmd'。
'cmd'只是新进程的参数列表，例如:Cmd[0]是要运行的程序，Cmd[1:]是它的其他参数。
不能以与其可执行文件不同的名称运行程序。
如果'search_path'为true(默认值)，将使用系统的可执行搜索路径来查找程序;否则,cmd[0]必须是可执行文件的确切路径。
如果'dry_run'为true，该命令将不会实际运行。
如果运行程序以任何方式失败，引发DistutilsExecError;只要成功就可以回报。

🌿7 mkpath(name, mode=511, verbose=1, dry_run=0)

mkpath(name, mode=511, verbose=1, dry_run=0), module=distutils.dir_util, line:17 at site-packages\setuptools_distutils\dir_util.py

创建一个目录和任何缺失的祖先目录。
如果目录已经存在(或者如果'name'是空字符串，这意味着当前目录，当然是存在的)，那么什么都不做。
如果在此过程中无法创建某个目录(例如:存在一些子路径，但是文件而不是目录)。
如果'verbose'为true，则将每个mkdir的一行摘要打印到stdout。返回实际创建的目录列表。

🌿8 _get_gid(name)

_get_gid(name), module=setuptools._distutils.archive_util, line:31 at site-packages\setuptools_distutils\archive_util.py

返回给定组名的gid。

🌿9 _get_uid(name)

_get_uid(name), module=setuptools._distutils.archive_util, line:43 at site-packages\setuptools_distutils\archive_util.py

给定用户名，返回uid。

🌿10 make_tarball(base_name, base_dir, compress=‘gzip’, verbose=0, dry_run=0, owner=None, group=None)

make_tarball(base_name, base_dir, compress=‘gzip’, verbose=0, dry_run=0, owner=None, group=None), module=setuptools._distutils.archive_util, line:55 at site-packages\setuptools_distutils\archive_util.py

从'base_dir'下的所有文件创建一个(可能是压缩的)tar文件。
'compress'必须为"gzip"(默认值)，"bzip2"， "xz"， "compress"或None。("compress"将在Python 3.2中弃用)
'owner'和'group'可用于定义正在构建的存档的所有者和组。如果没有提供，将使用当前的所有者和组。
输出的tar文件将被命名为“base_dir”+“.tar”，可能会加上适当的压缩扩展名(".gz", ".bz2", ".xz" 或“.z”)。
返回输出文件名。

🌿11 make_zipfile(base_name, base_dir, verbose=0, dry_run=0)

make_zipfile(base_name, base_dir, verbose=0, dry_run=0), module=setuptools._distutils.archive_util, line:127 at site-packages\setuptools_distutils\archive_util.py

从'base_dir'下的所有文件创建一个zip文件。
输出的zip文件将被命名为 'base_name'+“.zip”。
使用"zipfile" Python模块(如果可用)或InfoZIP "zip"实用程序(如果安装并在默认搜索路径上找到)。
如果这两个工具都不可用，则引发DistutilsExecError。返回输出zip文件的名称。

🌿12 check_archive_formats(formats)

check_archive_formats(formats), module=setuptools._distutils.archive_util, line:196 at site-packages\setuptools_distutils\archive_util.py

返回'format'列表中未知的第一个格式。如果所有格式都已知，则返回None

🌿13 make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0, dry_run=0, owner=None, group=None)

make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0, dry_run=0, owner=None, group=None), module=setuptools._distutils.archive_util, line:206 at site-packages\setuptools_distutils\archive_util.py

创建一个归档文件(例如:Zip或tar)。
'base_name'是要创建的文件的名称，减去任何格式特定的扩展名;format为归档格式:“zip”、“tar”、“gztar”、“bztar”、“xztar”或“ztar”之一。
'root_dir'是一个将作为归档文件根目录的目录;即，在创建归档文件之前，我们通常会将chdir目录设置为'root_dir'。
'base_dir'是我们开始归档的目录;即，'base_dir'将是归档文件中所有文件和目录的通用前缀。
'root_dir'和'base_dir'都默认为当前目录。
返回存档文件的名称。'owner'和'group'在创建tar存档时使用。
默认情况下，使用当前所有者和组。

🔵类

🌿14 distutils.errors.DistutilsExecError

DistutilsExecError, distutils.errors.DistutilsExecError, module=distutils.errors, line:0 at

🔵内嵌函数或方法

14 warn

🔵私有或局部

15 _get_gid <function _get_gid at 0x00000195B7749948>
16 _get_uid <function _get_uid at 0x00000195B774E8B8>

🔵剩余

17 loader <_frozen_importlib_external.SourceFileLoader object at 0x00000195B774A448>
18 spec ModuleSpec(name=‘setuptools._distutils.archive_util’, loader=<_frozen_importlib_external.SourceFileLoader object at 0x00000195B774A448>, origin=‘…\lib\site-packages\setuptools\_distutils\archive_util.py’)
19 getpwnam
20 getgrnam

☘️【distutils.cmd】

cmd, fullname=distutils.cmd, file=distutils\cmd.py

提供Command类，它是distutils.command包中命令类的基类。

☘️【distutils.core】

core, fullname=distutils.core, file=distutils\core.py

要使用Distutils，唯一需要导入的模块;提供'setup'函数(将从设置脚本调用)。
还间接提供了Distribution和Command类，尽管它们实际上是在 distutils.dist 和 distutils.cmd 中定义的。

☘️【distutils.filelist】

filelist, fullname=distutils.filelist, file=distutils\filelist.py

提供filelist类，用于查看文件系统和构建文件列表。

☘️【distutils.ccompiler】

ccompiler, fullname=distutils.ccompiler, file=distutils\ccompiler.py

包含 CCompiler，一个抽象基类，用于定义Distutils编译器抽象模型的接口。

☘️【distutils.msvc9compiler】

msvc9compiler, fullname=distutils.msvc9compiler, file=distutils\msvc9compiler.py

包含MSVCCompiler，一个用于Microsoft Visual Studio 2008的抽象CCompiler类的实现。
该模块兼容vs2005和vs2008。你可以在distutils.msvccompiler中找到对旧版本VS的支持。

☘️【distutils._msvccompiler】

_msvccompiler, fullname=distutils._msvccompiler, file=distutils_msvccompiler.py

包含 MSVCCompiler，一个用于Microsoft Visual Studio 2015的抽象CCompiler类的实现。
该模块兼容VS 2015及更高版本。您可以在distutils中找到对旧版本的遗留支持。msvc9编译器和distutils。

☘️【pkg_resources】

pkg_resources, fullname=pkg_resources, file=pkg_resources_init_.py

Package resource API
资源是包中包含的逻辑文件，或逻辑文件子目录。

☘️【setuptools._vendor.packaging】

packaging, fullname=setuptools.vendor.packaging, file=setuptools_vendor\packaging_init.py

🔵统计

序号	类别	数量
4	str	12
6	list	2
8	dict	1
9	module	8
13	residual	3
14	system	19
15	private	3
16	all	26

🔵常量

🔵模块

🌿1 setuptools.extern.packaging._structures

_structures, fullname=setuptools.extern.packaging._structures, file=setuptools_vendor\packaging_structures.py

🌿2 setuptools.extern.packaging.version

version, fullname=setuptools.extern.packaging.version, file=setuptools_vendor\packaging\version.py

🌿3 setuptools._vendor.packaging._manylinux

_manylinux, fullname=setuptools._vendor.packaging._manylinux, file=setuptools_vendor\packaging_manylinux.py

🌿4 setuptools._vendor.packaging._musllinux

_musllinux, fullname=setuptools._vendor.packaging._musllinux, file=setuptools_vendor\packaging_musllinux.py

PEP 656支持。
该模块实现了检测当前运行的Python是否与musl相关联以及使用哪个musl版本的逻辑。

🌿5 setuptools.extern.packaging.tags

tags, fullname=setuptools.extern.packaging.tags, file=setuptools_vendor\packaging\tags.py

🌿6 setuptools.extern.packaging.utils

utils, fullname=setuptools.extern.packaging.utils, file=setuptools_vendor\packaging\utils.py

🌿7 setuptools.extern.packaging.specifiers

specifiers, fullname=setuptools.extern.packaging.specifiers, file=setuptools_vendor\packaging\specifiers.py

🔵私有或局部

8 _structures <module ‘setuptools.extern.packaging._structures’ from ‘…\lib\site-packages\setuptools\_vendor\packaging\_structures.py’>
9 _manylinux <module ‘setuptools._vendor.packaging._manylinux’ from ‘…\lib\site-packages\setuptools\_vendor\packaging\_manylinux.py’>
10 _musllinux <module ‘setuptools._vendor.packaging._musllinux’ from ‘…\lib\site-packages\setuptools\_vendor\packaging\_musllinux.py’>

☘️【setuptools._vendor.ordered_set】

ordered_set, fullname=setuptools._vendor.ordered_set, file=setuptools_vendor\ordered_set.py

OrderedSet是一个自定义的MutableSet，它记住了自己的顺序，因此每个条目都有一个可以查找的索引。
基于Raymond Hettiger最初发布到ActiveState Recipes的食谱，并在MIT许可下发布。

🔵统计

序号	类别	数量
4	str	6
8	dict	1
9	module	1
10	class	4
11	function	1
13	residual	3
14	system	9
16	all	16

🔵常量

🔵模块

🌿1 itertools

itertools, fullname=itertools, file=

🔵函数

🌿2 is_iterable(obj)

is_iterable(obj), module=setuptools._vendor.ordered_set, line:22 at site-packages\setuptools_vendor\ordered_set.py

我们是否被要求查找一系列的东西，而不是单个的东西?我们检查 `__iter__` 属性，以便它可以覆盖该模块不需要知道的类型，例如NumPy数组。
然而，字符串应该被视为要查找的原子值，而不是可迭代对象。
元组也是如此，因为它们是不可变的，因此是有效的条目。
我们不需要检查Python 2的 `unicode` 类型，因为它没有 `__iter__` 属性。

🔵类

🌿3 collections.deque

deque, collections.deque, module=collections, line:-1 at collections_init_.py

🌿4 collections.abc.MutableSet

MutableSet, collections.abc.MutableSet, module=collections.abc, line:-1 at collections\abc.py

🌿5 collections.abc.Sequence

Sequence, collections.abc.Sequence, module=collections.abc, line:-1 at collections\abc.py

🌿6 setuptools._vendor.ordered_set.OrderedSet

OrderedSet, setuptools._vendor.ordered_set.OrderedSet, module=setuptools._vendor.ordered_set, line:42 at site-packages\setuptools_vendor\ordered_set.py

OrderedSet是一个自定义的MutableSet，它记住了自己的顺序，因此每个条目都有一个可以查找的索引。
示例:
        >>> OrderedSet([1, 1, 2, 3, 2])
        OrderedSet([1, 2, 3])

method

1 add(self, key)

kind=method class=OrderedSet objtype=function line:145 at …\lib\site-packages\setuptools_vendor\ordered_set.py

将'key'作为一个项添加到这个OrderedSet，然后返回它的索引。
如果'key'已经在OrderedSet中，则返回它已经拥有的索引。
示例:
            >>> oset = OrderedSet()
            >>> oset.append(3)
            0
            >>> print(oset)
            OrderedSet([3])

2 append()

kind=method class=OrderedSet objtype=function

将`key`作为一个项添加到这个OrderedSet，然后返回它的索引。
如果`key`已经在OrderedSet中，则返回它已经拥有的索引。
示例:
            >>> oset = OrderedSet()
            >>> oset.append(3)
            0
            >>> print(oset)
            OrderedSet([3])

3 clear(self)

kind=method class=OrderedSet objtype=function line:252 at …\lib\site-packages\setuptools_vendor\ordered_set.py

从这个OrderedSet中删除所有项。

4 copy(self)

kind=method class=OrderedSet objtype=function line:101 at …\lib\site-packages\setuptools_vendor\ordered_set.py

返回该对象的浅拷贝。
示例:
            >>> this = OrderedSet([1, 2, 3])
            >>> other = this.copy()
            >>> this == other
            True
            >>> this is other
            False

5 difference(self, *sets)

kind=method class=OrderedSet objtype=function line:355 at …\lib\site-packages\setuptools_vendor\ordered_set.py

返回此集合中的所有元素，但不包括其他元素。
示例:
            >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]))
            OrderedSet([1, 3])
            >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]), OrderedSet([3]))
            OrderedSet([1])
            >>> OrderedSet([1, 2, 3]) - OrderedSet([2])
            OrderedSet([1, 3])
            >>> OrderedSet([1, 2, 3]).difference()
            OrderedSet([1, 2, 3])

6 difference_update(self, *sets)

kind=method class=OrderedSet objtype=function line:437 at …\lib\site-packages\setuptools_vendor\ordered_set.py

更新此OrderedSet以从一个或多个其他集合中删除项。
示例:
            >>> this = OrderedSet([1, 2, 3])
            >>> this.difference_update(OrderedSet([2, 4]))
            >>> print(this)
            OrderedSet([1, 3])
            >>> this = OrderedSet([1, 2, 3, 4, 5])
            >>> this.difference_update(OrderedSet([2, 4]), OrderedSet([1, 4, 6]))
            >>> print(this)
            OrderedSet([3, 5])

7 discard(self, key)

kind=method class=OrderedSet objtype=function line:228 at …\lib\site-packages\setuptools_vendor\ordered_set.py

移除一个元素。如果缺席，不要引发异常。
MutableSet mixin使用这个来实现.remove()方法，当被要求删除一个不存在的项目时，该方法会引发一个错误。
示例:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.discard(2)
            >>> print(oset)
            OrderedSet([1, 3])
            >>> oset.discard(2)
            >>> print(oset)
            OrderedSet([1, 3])

8 get_indexer()

kind=method class=OrderedSet objtype=function

获取给定条目的索引，如果不存在则引发IndexError。
'key'可以是一个非字符串的可迭代项，在这种情况下，它返回一个索引列表。
示例:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.index(2)
            1

9 get_loc()

kind=method class=OrderedSet objtype=function

获取给定条目的索引，如果不存在则引发IndexError。
`key`可以是一个非字符串的可迭代项，在这种情况下，它返回一个索引列表。
示例:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.index(2)
            1

10 index(self, key)

kind=method class=OrderedSet objtype=function line:188 at …\lib\site-packages\setuptools_vendor\ordered_set.py

获取给定条目的索引，如果不存在则引发IndexError。
`key`可以是一个非字符串的可迭代项，在这种情况下，它返回一个索引列表。
示例:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.index(2)
            1

11 intersection(self, *sets)

kind=method class=OrderedSet objtype=function line:333 at …\lib\site-packages\setuptools_vendor\ordered_set.py

返回所有集合之间的公共元素。
顺序仅由第一个集合定义。示例:
            >>> oset = OrderedSet.intersection(OrderedSet([0, 1, 2, 3]), [1, 2, 3])
            >>> print(oset)
            OrderedSet([1, 2, 3])
            >>> oset.intersection([2, 4, 5], [1, 2, 3, 4])
            OrderedSet([2])
            >>> oset.intersection()
            OrderedSet([1, 2, 3])

12 intersection_update(self, other)

kind=method class=OrderedSet objtype=function line:457 at …\lib\site-packages\setuptools_vendor\ordered_set.py

更新此OrderedSet以仅保留另一个集合中的项，并保留它们在该集合中的顺序。
示例:
            >>> this = OrderedSet([1, 4, 3, 5, 7])
            >>> other = OrderedSet([9, 7, 1, 3, 2])
            >>> this.intersection_update(other)
            >>> print(this)
            OrderedSet([1, 3, 7])

13 issubset(self, other)

kind=method class=OrderedSet objtype=function line:377 at …\lib\site-packages\setuptools_vendor\ordered_set.py

报告其他集合是否包含此集合。
示例:
            >>> OrderedSet([1, 2, 3]).issubset({1, 2})
            False
            >>> OrderedSet([1, 2, 3]).issubset({1, 2, 3, 4})
            True
            >>> OrderedSet([1, 2, 3]).issubset({1, 4, 3, 5})
            False

14 issuperset(self, other)

kind=method class=OrderedSet objtype=function line:393 at …\lib\site-packages\setuptools_vendor\ordered_set.py

报告此集合是否包含另一个集合。示例:
            >>> OrderedSet([1, 2]).issuperset([1, 2, 3])
            False
            >>> OrderedSet([1, 2, 3, 4]).issuperset({1, 2, 3})
            True
            >>> OrderedSet([1, 4, 3, 5]).issuperset({1, 2, 3})
            False

15 pop(self)

kind=method class=OrderedSet objtype=function line:209 at …\lib\site-packages\setuptools_vendor\ordered_set.py

移除并返回集合中的最后一个元素。
如果集合为空则引发KeyError。示例:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.pop()
            3

16 symmetric_difference(self, other)

kind=method class=OrderedSet objtype=function line:409 at …\lib\site-packages\setuptools_vendor\ordered_set.py

返回两个OrderedSets的对称差值作为一个新集合。
也就是说，新集合将包含恰好在其中一个集合中的所有元素。
它们的顺序将保持不变，`self`的元素位于`other`的元素之前。
示例:
            >>> this = OrderedSet([1, 4, 3, 5, 7])
            >>> other = OrderedSet([9, 7, 1, 3, 2])
            >>> this.symmetric_difference(other)
            OrderedSet([4, 5, 9, 2])

17 symmetric_difference_update(self, other)

kind=method class=OrderedSet objtype=function line:472 at …\lib\site-packages\setuptools_vendor\ordered_set.py

更新此OrderedSet以从另一个集合中删除项目，然后从另一个集合中添加此集合中不存在的项目。
示例:
            >>> this = OrderedSet([1, 4, 3, 5, 7])
            >>> other = OrderedSet([9, 7, 1, 3, 2])
            >>> this.symmetric_difference_update(other)
            >>> print(this)
            OrderedSet([4, 5, 9, 2])

18 union(self, *sets)

kind=method class=OrderedSet objtype=function line:310 at …\lib\site-packages\setuptools_vendor\ordered_set.py

组合所有独特的物品。每个项的顺序由其第一次出现定义。
示例:
            >>> oset = OrderedSet.union(OrderedSet([3, 1, 4, 1, 5]), [1, 3], [2, 0])
            >>> print(oset)
            OrderedSet([3, 1, 4, 5, 2, 0])
            >>> oset.union([8, 9])
            OrderedSet([3, 1, 4, 5, 2, 0, 8, 9])
            >>> oset | {10}
            OrderedSet([3, 1, 4, 5, 2, 0, 10])

19 update(self, sequence)

kind=method class=OrderedSet objtype=function line:166 at …\lib\site-packages\setuptools_vendor\ordered_set.py

用给定的可迭代序列更新集合，然后返回最后插入元素的索引。
示例:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.update([3, 1, 5, 1, 4])
            4
            >>> print(oset)
            OrderedSet([1, 2, 3, 5, 4])

🔵剩余

7 loader <_frozen_importlib_external.SourceFileLoader object at 0x0000028306DCD388>
8 spec ModuleSpec(name=‘setuptools.extern.ordered_set’, loader=<setuptools.extern.VendorImporter object at 0x0000028306DB7E88>)
9 SLICE_ALL slice(None, None, None)

☘️【setuptools._vendor.more_itertools】

more_itertools, fullname=setuptools.vendor.more_itertools, file=setuptools_vendor\more_itertools_init.py

🔵统计

序号	类别	数量
4	str	5
6	list	1
8	dict	1
9	module	2
10	class	12
11	function	100
13	residual	3
14	system	10
16	all	124

🔵常量

🔵模块

🌿1 setuptools._vendor.more_itertools.recipes

recipes, fullname=setuptools._vendor.more_itertools.recipes, file=setuptools_vendor\more_itertools\recipes.py

从itertools文档的recipes部分导入。
所有函数都取自itertools库docs[1]的recipes部分。
一些向后兼容的可用性改进已经完成。
[参见1](http://docs.python.org/library/itertools.html#recipes)

🌿2 setuptools._vendor.more_itertools.more

more, fullname=setuptools._vendor.more_itertools.more, file=setuptools_vendor\more_itertools\more.py

🔵函数

🌿3 adjacent(predicate, iterable, distance=1)

adjacent(predicate, iterable, distance=1), module=setuptools._vendor.more_itertools.more, line:1805 at site-packages\setuptools_vendor\more_itertools\more.py

在 `(bool, item)` 元组上返回一个可迭代对象，其中`item`从*iterable*中提取，`bool`指示该项目是否满足*谓词*或与满足*谓词*的项目相邻。
    例如，要查找项是否与``3``相邻:
        >>> list(adjacent(lambda x: x == 3, range(6)))
        [(False, 0), (False, 1), (True, 2), (True, 3), (True, 4), (False, 5)]
    设置*distance*以更改相邻的计数。例如，要查找项目是否与``3``相差两个位置:
        >>> list(adjacent(lambda x: x == 3, range(6), distance=2))
        [(False, 0), (True, 1), (True, 2), (True, 3), (True, 4), (True, 5)]
    这对于将搜索函数的结果上下文化很有用。
    例如，代码比较工具可能想要识别已更改的行，但也要识别周围的行，以便向查看者提供diff上下文。
    对于可迭代对象中的每个项，谓词函数只被调用一次。
    另请参见 :func:`groupby_transform` ，它可以与此函数一起使用，对具有相同`bool`值的项范围进行分组。

🌿4 always_iterable(obj, base_type=(<class ‘str’>, <class ‘bytes’>))

always_iterable(obj, base_type=(<class ‘str’>, <class ‘bytes’>)), module=setuptools._vendor.more_itertools.more, line:1752 at site-packages\setuptools_vendor\more_itertools\more.py

    如果*obj*是可迭代的，返回一个遍历其项的迭代器:
        >>> obj = (1, 2, 3)
        >>> list(always_iterable(obj))
        [1, 2, 3]
    如果*obj*不是可迭代的，返回一个包含*obj*:
        >>> obj = 1
        >>> list(always_iterable(obj))
        [1]
    如果*obj*是``None``，返回一个空的可迭代对象:
        >>> obj = None
        >>> list(always_iterable(None))
        []
    默认情况下，二进制字符串和文本字符串不被认为是可迭代的:
        >>> obj = 'foo'
        >>> list(always_iterable(obj))
        ['foo']
    如果设置了*base_type*， ``isinstance(obj, base_type)`` 返回``True``的对象将不被认为是可迭代的。
        >>> obj = {'a': 1}
        >>> list(always_iterable(obj))  # Iterate over the dict's keys
        ['a']
        >>> list(always_iterable(obj, base_type=dict))  # Treat dicts as a unit
        [{'a': 1}]
    将 *base_type* 设置为``None``以避免任何特殊处理并将Python认为可迭代的对象视为可迭代的:
        >>> obj = 'foo'
        >>> list(always_iterable(obj, base_type=None))
        ['f', 'o', 'o']

🌿5 always_reversible(iterable)

always_reversible(iterable), module=setuptools._vendor.more_itertools.more, line:2410 at site-packages\setuptools_vendor\more_itertools\more.py

:func:`func`的扩展，支持所有可迭代对象，而不仅仅是那些实现 ``Reversible`` 或 ``Sequence`` 协议的对象。
        >>> print(*always_reversible(x for x in range(3)))
        2 1 0
    如果可迭代对象已经是可逆的，此函数返回 :func:`reversed()` 的结果。
    如果可迭代对象不可逆，则此函数将缓存可迭代对象中的剩余项，并以相反的顺序生成它们，这可能需要大量存储空间。

🌿6 chunked(iterable, n, strict=False)

chunked(iterable, n, strict=False), module=setuptools._vendor.more_itertools.more, line:127 at site-packages\setuptools_vendor\more_itertools\more.py

    将*iterable*分解为长度为*n*的列表:
        >>> list(chunked([1, 2, 3, 4, 5, 6], 3))
        [[1, 2, 3], [4, 5, 6]]
    默认情况下，如果*iterable*的长度不能被*n*整除，则最后生成的列表将少于*n*个元素]:
        >>> list(chunked([1, 2, 3, 4, 5, 6, 7, 8], 3))
        [[1, 2, 3], [4, 5, 6], [7, 8]]
    要使用填充值，请参阅:func:`grouper` 。
    如果*iterable*的长度不能被*n*整除，而*strict*是``True``，那么``ValueError``将在最后一个列表生成之前引发。

🌿7 circular_shifts(iterable)

circular_shifts(iterable), module=setuptools._vendor.more_itertools.more, line:2750 at site-packages\setuptools_vendor\more_itertools\more.py

返回*iterable*的循环移位列表。
    >>> circular_shifts(range(4))
    [(0, 1, 2, 3), (1, 2, 3, 0), (2, 3, 0, 1), (3, 0, 1, 2)]

🌿8 collapse(iterable, base_type=None, levels=None)

collapse(iterable, base_type=None, levels=None), module=setuptools._vendor.more_itertools.more, line:1020 at site-packages\setuptools_vendor\more_itertools\more.py

    将具有多层嵌套的可迭代对象(例如，元组列表的列表)扁平化为不可迭代类型。
        >>> iterable = [(1, 2), ([3, 4], [[5], [6]])]
        >>> list(collapse(iterable))
        [1, 2, 3, 4, 5, 6]
    二进制字符串和文本字符串不被认为是可迭代的，不会被折叠。
    为了避免崩溃的其他类型,指定 *base_type*:
        >>> iterable = ['ab', ('cd', 'ef'), ['gh', 'ij']]
        >>> list(collapse(iterable, base_type=tuple))
        ['ab', ('cd', 'ef'), 'gh', 'ij']
    指定*levels*以在某一关卡后停止扁平化:
        >>> iterable = [('a', ['b']), ('c', ['d'])]
        >>> list(collapse(iterable))  # Fully flattened
        ['a', 'b', 'c', 'd']
        >>> list(collapse(iterable, levels=1))  # Only one level flattened
        ['a', ['b'], 'c', ['d']]

🌿9 collate(*iterables, **kwargs)

collate(*iterables, **kwargs), module=setuptools._vendor.more_itertools.more, line:399 at site-packages\setuptools_vendor\more_itertools\more.py

    返回几个已经排序的*可迭代对象*中的每个项的排序合并。
        >>> list(collate('ACDZ', 'AZ', 'JKL'))
        ['A', 'A', 'C', 'D', 'J', 'K', 'L', 'Z', 'Z']
    惰性工作，只保留每个可迭代对象的下一个值在内存中。
    例如，使用:func:`func`来对内存中无法容纳的项执行n向归并排序。
    如果指定了*key*函数，则可迭代对象将根据其结果排序:
        >>> key = lambda s: int(s)  # Sort by numeric value, not by string
        >>> list(collate(['1', '10'], ['2', '11'], key=key))
        ['1', '2', '10', '11']
    如果*可迭代对象*按降序排序，则将*reverse*设置为``True``:
        >>> list(collate([5, 3, 1], [4, 2, 0], reverse=True))
        [5, 4, 3, 2, 1, 0]
    如果传入的可迭代对象的元素无序，则可能会得到意想不到的结果。
    在Python 3.5+中，此函数是 :func:`heapq.merge` 的别名。

🌿10 consecutive_groups(iterable, ordering=<function at 0x0000028306E0C5E8>)

consecutive_groups(iterable, ordering=<function at 0x0000028306E0C5E8>), module=setuptools._vendor.more_itertools.more, line:2428 at site-packages\setuptools_vendor\more_itertools\more.py

    使用:func:'itertools.groupby'生成连续条目的组。
    *ordering*函数通过返回两个项的位置来确定它们是否相邻。
    缺省情况下，排序函数为恒等函数。这适用于查找数字的运行:
        >>> iterable = [1, 10, 11, 12, 20, 30, 31, 32, 33, 40]
        >>> for group in consecutive_groups(iterable):
        ...     print(list(group))
        [1]
        [10, 11, 12]
        [20]
        [30, 31, 32, 33]
        [40]
    要查找相邻字母的运行，请尝试使用字母字符串的:meth:`meth`方法:
        >>> from string import ascii_lowercase
        >>> iterable = 'abcdfgilmnop'
        >>> ordering = ascii_lowercase.index
        >>> for group in consecutive_groups(iterable, ordering):
        ...     print(list(group))
        ['a', 'b', 'c', 'd']
        ['f', 'g']
        ['i']
        ['l', 'm', 'n', 'o', 'p']
    每一组连续的项目都是一个迭代器，共享它的源 *iterable*。
    当一个输出组被推进时，前一个组不再可用，除非它的元素被复制(例如，复制到一个“列表”中)。
        >>> iterable = [1, 2, 11, 12, 21, 22]
        >>> saved_groups = []
        >>> for group in consecutive_groups(iterable):
        ...     saved_groups.append(list(group))  # Copy group elements
        >>> saved_groups
        [[1, 2], [11, 12], [21, 22]]

🌿11 consumer(func)

consumer(func), module=setuptools._vendor.more_itertools.more, line:437 at site-packages\setuptools_vendor\more_itertools\more.py

自动将pep -342风格的“反向迭代器”推进到其第一个生成点的装饰器，因此您不必手动调用``next()``。
        >>> @consumer
        ... def tally():
        ...     i = 0
        ...     while True:
        ...         print('Thing number %s is %s.' % (i, (yield)))
        ...         i += 1
        ...
        >>> t = tally()
        >>> t.send('red')
        Thing number 0 is red.
        >>> t.send('fish')
        Thing number 1 is fish.
    如果没有装饰器，你就必须在使用t.send()之前调用 ``next(t)``。

🌿12 count_cycle(iterable, n=None)

count_cycle(iterable, n=None), module=setuptools._vendor.more_itertools.more, line:2106 at site-packages\setuptools_vendor\more_itertools\more.py

从*iterable*到*n*次循环遍历项目，生成每个项目完成循环的次数。
如果省略*n*，则该过程无限重复。
    >>> list(count_cycle('AB', 3))
    [(0, 'A'), (0, 'B'), (1, 'A'), (1, 'B'), (2, 'A'), (2, 'B')]

🌿13 mark_ends(iterable)

mark_ends(iterable), module=setuptools._vendor.more_itertools.more, line:2122 at site-packages\setuptools_vendor\more_itertools\more.py

生成形式为``(is first, is last, item)``的三元组。
    >>> list(mark_ends('ABC'))
    [(True, False, 'A'), (False, False, 'B'), (False, True, 'C')]
在循环遍历可迭代对象以对其第一项和/或最后项采取特殊操作时使用:
    >>> iterable = ['Header', 100, 200, 'Footer']
    >>> total = 0
    >>> for is_first, is_last, item in mark_ends(iterable):
    ...     if is_first:
    ...         continue  # Skip the header
    ...     if is_last:
    ...         continue  # Skip the footer
    ...     total += item
    >>> print(total)
    300

🌿14 difference(iterable, func=, *, initial=None)

difference(iterable, func=, *, initial=None), module=setuptools._vendor.more_itertools.more, line:2476 at site-packages\setuptools_vendor\more_itertools\more.py

    这个函数是 :func:`itertools.accumulate` 的逆函数。
    默认情况下，它将使用 :func:`operator.sub` 计算*iterable*的第一个差值。
        >>> from itertools import accumulate
        >>> iterable = accumulate([0, 1, 2, 3, 4])  # produces 0, 1, 3, 6, 10
        >>> list(difference(iterable))
        [0, 1, 2, 3, 4]
    *func*默认为 :func:`operator.sub`，但可以指定其他函数。它们将被应用如下:
        A, B, C, D, ... --> A, func(B, A), func(C, B), func(D, C), ...
    例如，要执行累进除法:
        >>> iterable = [1, 2, 6, 24, 120]
        >>> func = lambda x, y: x // y
        >>> list(difference(iterable, func))
        [1, 2, 3, 4, 5]
    如果设置了*initial*关键字，则在计算连续差时将跳过第一个元素。
        >>> it = [10, 11, 13, 16]  # from accumulate([1, 2, 3], initial=10)
        >>> list(difference(it, initial=10))
        [1, 2, 3]

🌿15 distinct_combinations(iterable, r)

distinct_combinations(iterable, r), module=setuptools._vendor.more_itertools.more, line:3195 at site-packages\setuptools_vendor\more_itertools\more.py

从*iterable*中获取*r*项的不同组合。
        >>> list(distinct_combinations([0, 0, 1], 2))
        [(0, 0), (0, 1)]
相当于``set(combination (iterable))``，只是不会生成并丢弃重复项。对于较大的输入序列，这要有效得多。

🌿16 distinct_permutations(iterable, r=None)

distinct_permutations(iterable, r=None), module=setuptools._vendor.more_itertools.more, line:581 at site-packages\setuptools_vendor\more_itertools\more.py

    生成*iterable*中元素的连续不同排列。
        >>> sorted(distinct_permutations([1, 0, 1]))
        [(0, 1, 1), (1, 0, 1), (1, 1, 0)]
    等价于``set(permutations(iterable))``，不同之处在于重复项不会生成并被丢弃。
    对于较大的输入序列，这要有效得多。
    当输入可迭代对象中存在重复元素时，就会出现重复排列。返回的项数为
        `n! / (x_1! * x_2! * ... * x_n!)`,
    其中`n`是输入项的总数，每个 `x_i`  是输入序列中不同项的计数。
    如果给定*r*，则只产生*r*长度的排列。
        >>> sorted(distinct_permutations([1, 0, 1], r=2))
        [(0, 1), (1, 0), (1, 1)]
        >>> sorted(distinct_permutations(range(3), r=2))
        [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]

🌿17 distribute(n, iterable)

distribute(n, iterable), module=setuptools._vendor.more_itertools.more, line:1419 at site-packages\setuptools_vendor\more_itertools\more.py

    将*iterable*中的项分发到*n*个较小的可迭代对象中。
        >>> group_1, group_2 = distribute(2, [1, 2, 3, 4, 5, 6])
        >>> list(group_1)
        [1, 3, 5]
        >>> list(group_2)
        [2, 4, 6]
    如果*iterable*的长度不能被*n*整除，则返回的可迭代对象的长度将不相同:
        >>> children = distribute(3, [1, 2, 3, 4, 5, 6, 7])
        >>> [list(c) for c in children]
        [[1, 4, 7], [2, 5], [3, 6]]
    如果*iterable*的长度小于*n*，则最后返回的可迭代对象将为空:
        >>> children = distribute(5, [1, 2, 3])
        >>> [list(c) for c in children]
        [[1], [2], [3], [], []]
    此函数使用:func:`itertools。并且可能需要大量的存储空间。如果你需要较小的可迭代对象中的顺序项与原始可迭代对象匹配，请参见:func:`func`。

🌿18 divide(n, iterable)

divide(n, iterable), module=setuptools._vendor.more_itertools.more, line:1701 at site-packages\setuptools_vendor\more_itertools\more.py

    将*iterable*中的元素划分为*n*个部分，保持顺序。
        >>> group_1, group_2 = divide(2, [1, 2, 3, 4, 5, 6])
        >>> list(group_1)
        [1, 2, 3]
        >>> list(group_2)
        [4, 5, 6]
    如果*iterable*的长度不能被*n*整除，则返回的可迭代对象的长度将不相同:
        >>> children = divide(3, [1, 2, 3, 4, 5, 6, 7])
        >>> [list(c) for c in children]
        [[1, 2, 3], [4, 5], [6, 7]]
    如果可迭代对象的长度小于n，那么最后返回的可迭代对象将为空:
        >>> children = divide(5, [1, 2, 3])
        >>> [list(c) for c in children]
        [[1], [2], [3], [], []]
    此函数将在返回前耗尽可迭代对象，并且可能需要大量存储空间。如果顺序不重要，请参阅:func:`func`，它不会首先将可迭代对象拉入内存。

🌿19 exactly_n(iterable, n, predicate=<class ‘bool’>)

exactly_n(iterable, n, predicate=<class ‘bool’>), module=setuptools._vendor.more_itertools.more, line:2732 at site-packages\setuptools_vendor\more_itertools\more.py

    根据*predicate*函数，如果可迭代对象中恰好有``n``项为``True``，则返回``True``。
        >>> exactly_n([True, True, False], 2)
        True
        >>> exactly_n([True, True, False], 1)
        False
        >>> exactly_n([0, 1, 2, 3, 4, 5], 3, lambda x: x < 3)
        True
    该可迭代对象将被推进到遇到 ``n + 1`` 真值项，因此避免在无限可迭代对象上调用它。

🌿20 filter_except(validator, iterable, *exceptions)

filter_except(validator, iterable, *exceptions), module=setuptools._vendor.more_itertools.more, line:3235 at site-packages\setuptools_vendor\more_itertools\more.py

    从*iterable*中生成*validator*函数不会引发指定的*异常之一的项。
    对*iterable*中的每个项调用*validator*。
    它应该是一个接受一个参数并在该参数无效时引发异常的函数。
        >>> iterable = ['1', '2', 'three', '4', None]
        >>> list(filter_except(int, iterable, ValueError, TypeError))
        ['1', '2', '4']
    如果由*validator*引发的异常不是由*exceptions*给出的异常，则会像正常一样引发。

🌿21 first(iterable, default=<object object at 0x000002830651A4A0>)

first(iterable, default=<object object at 0x000002830651A4A0>), module=setuptools._vendor.more_itertools.more, line:160 at site-packages\setuptools_vendor\more_itertools\more.py

    返回*iterable*的第一项，如果*iterable*为空则返回*default*。
            >>> first([0, 1, 2, 3])
            0
            >>> first([], 'some default')
            'some default'
    如果未提供*default*且可迭代对象中没有项，则引发``ValueError``。
    :func:`func`在您有一个难以检索的值的生成器并想要任意一个值时非常有用。它比 ``next(iter(iterable), default)`` 略短。

🌿22 groupby_transform(iterable, keyfunc=None, valuefunc=None, reducefunc=None)

groupby_transform(iterable, keyfunc=None, valuefunc=None, reducefunc=None), module=setuptools._vendor.more_itertools.more, line:1844 at site-packages\setuptools_vendor\more_itertools\more.py

    :func:`itertools的扩展。可以对分组数据应用转换的Groupby。
        * *keyfunc*是一个计算*iterable中每个项的键值的函数
        * *valuefunc*是一个将*iterable*中的单个项进行分组后进行转换的函数
        * *reducefunc*是一个将每组项进行转换的函数
        >>> iterable = 'aAAbBBcCC'
        >>> keyfunc = lambda k: k.upper()
        >>> valuefunc = lambda v: v.lower()
        >>> reducefunc = lambda g: ''.join(g)
        >>> list(groupby_transform(iterable, keyfunc, valuefunc, reducefunc))
        [('A', 'aaa'), ('B', 'bbb'), ('C', 'ccc')]
    :func:`groupby_transform` 在使用单独的可迭代对象作为键对可迭代对象的元素进行分组时很有用。
        >>> from operator import itemgetter
        >>> keys = [0, 0, 1, 1, 1, 2, 2, 2, 3]
        >>> values = 'abcdefghi'
        >>> iterable = zip(keys, values)
        >>> grouper = groupby_transform(iterable, itemgetter(0), itemgetter(1))
        >>> [(k, ''.join(g)) for k, g in grouper]
        [(0, 'ab'), (1, 'cde'), (2, 'fgh'), (3, 'i')]
    要做到这一点，:func:`zip`可迭代对象，并传递一个*keyfunc*来提取第一个元素，一个*valuefunc*来提取第二个元素:
    如果没有指定，每个可选参数默认为一个身份函数。

🌿23 ilen(iterable)

ilen(iterable), module=setuptools._vendor.more_itertools.more, line:469 at site-packages\setuptools_vendor\more_itertools\more.py

    返回*iterable*中的项数。
        >>> ilen(x for x in range(1000000) if x % 3 == 0)
        333334
    这会消耗可迭代对象，所以要小心处理。

🌿24 interleave_longest(*iterables)

interleave_longest(*iterables), module=setuptools._vendor.more_itertools.more, line:1004 at site-packages\setuptools_vendor\more_itertools\more.py

依次返回每个可迭代对象产生的新可迭代对象，跳过所有已耗尽的可迭代对象。
        >>> list(interleave_longest([1, 2, 3], [4, 5], [6, 7, 8]))
        [1, 4, 6, 2, 5, 7, 3, 8]
此函数产生与:func:`roundrobin`相同的输出，但对于某些输入可能表现更好(特别是当可迭代对象的数量很大时)。

🌿25 interleave(*iterables)

interleave(*iterables), module=setuptools._vendor.more_itertools.more, line:990 at site-packages\setuptools_vendor\more_itertools\more.py

    依次从每个可迭代对象中返回一个新的可迭代对象，直到最短的可迭代对象耗尽。
        >>> list(interleave([1, 2, 3], [4, 5], [6, 7, 8]))
        [1, 4, 6, 2, 5, 7]
    对于在最短可迭代对象耗尽后不终止的版本，请参见 :func:`interleave_longest`。

🌿26 intersperse(e, iterable, n=1)

intersperse(e, iterable, n=1), module=setuptools._vendor.more_itertools.more, line:681 at site-packages\setuptools_vendor\more_itertools\more.py

将填充元素*e*分散到*iterable*中的项中，在每个填充元素之间留下*n*项。
        >>> list(intersperse('!', [1, 2, 3, 4, 5]))
        [1, '!', 2, '!', 3, '!', 4, '!', 5]
        >>> list(intersperse(None, [1, 2, 3, 4, 5], n=2))
        [1, 2, None, 3, 4, None, 5]

🌿27 iterate(func, start)

iterate(func, start), module=setuptools._vendor.more_itertools.more, line:486 at site-packages\setuptools_vendor\more_itertools\more.py

返回：``start``, ``func(start)``, ``func(func(start))``, ...
    >>> from itertools import islice
    >>> list(islice(iterate(lambda x: 2*x, 1), 10))
    [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]

🌿28 ichunked(iterable, n)

ichunked(iterable, n), module=setuptools._vendor.more_itertools.more, line:3158 at site-packages\setuptools_vendor\more_itertools\more.py

    将*iterable*分解为子可迭代对象，每个子可迭代对象有*n*个元素。
    :func:`ichunked`类似于:func:`chunked`，但它产生的是可迭代对象而不是列表。
    如果按顺序读取子可迭代对象，则*iterable*的元素不会存储在内存中。
    如果它们被乱序读取，:func:`itertools.Tee'用于必要时缓存元素。
        >>> from itertools import count
        >>> all_chunks = ichunked(count(), 4)
        >>> c_1, c_2, c_3 = next(all_chunks), next(all_chunks), next(all_chunks)
        >>> list(c_2)  # c_1's elements have been cached; c_3's haven't been
        [4, 5, 6, 7]
        >>> list(c_1)
        [0, 1, 2, 3]
        >>> list(c_3)
        [8, 9, 10, 11]

🌿29 is_sorted(iterable, key=None, reverse=False)

is_sorted(iterable, key=None, reverse=False), module=setuptools._vendor.more_itertools.more, line:3377 at site-packages\setuptools_vendor\more_itertools\more.py

    如果iterable的项按顺序排列，则返回' True``，否则返回' False``。
    *key*和*reverse*的含义与内置:func:`sorted`函数中的含义相同。
        >>> is_sorted(['1', '2', '3', '4', '5'], key=int)
        True
        >>> is_sorted([5, 4, 3, 1, 2], reverse=True)
        False
    函数在遇到第一个乱序项后返回``False``。如果没有无序项，则耗尽可迭代对象。

🌿30 last(iterable, default=<object object at 0x000002830651A4A0>)

last(iterable, default=<object object at 0x000002830651A4A0>), module=setuptools._vendor.more_itertools.more, line:188 at site-packages\setuptools_vendor\more_itertools\more.py

返回*iterable*的最后一项，如果*iterable*为空，则返回*default*。
        >>> last([0, 1, 2, 3])
        3
        >>> last([], 'some default')
        'some default'
    如果未提供*default*且可迭代对象中没有项，则引发``ValueError``。

🌿31 locate(iterable, pred=<class ‘bool’>, window_size=None)

locate(iterable, pred=<class ‘bool’>, window_size=None), module=setuptools._vendor.more_itertools.more, line:2159 at site-packages\setuptools_vendor\more_itertools\more.py

    生成*iterable*中*pred*返回``True``的每个项的索引。
    *pred*默认为:func:`bool`，它将选择真实的项目:
            >>> list(locate([0, 1, 1, 0, 1, 0, 0]))
            [1, 2, 4]
    设置*pred*为自定义函数，例如，查找特定项目的索引。
            >>> list(locate(['a', 'b', 'c', 'b'], lambda x: x == 'b'))
            [1, 3]
    如果给出了*窗口大小*，则将调用*pred*函数并调用该项。这允许搜索子序列:
            >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
            >>> pred = lambda *args: args == (1, 2, 3)
            >>> list(locate(iterable, pred=pred, window_size=3))
            [1, 5, 9]
    使用:func:“seekable”然后找到索引和检索相关的项目:
            >>> from itertools import count
            >>> from more_itertools import seekable
            >>> source = (3 * n + 1 if (n % 2) else n // 2 for n in count())
            >>> it = seekable(source)
            >>> pred = lambda x: x > 100
            >>> indexes = locate(it, pred=pred)
            >>> i = next(indexes)
            >>> it.seek(i)
            >>> next(it)
            106

🌿32 lstrip(iterable, pred)

lstrip(iterable, pred), module=setuptools._vendor.more_itertools.more, line:2207 at site-packages\setuptools_vendor\more_itertools\more.py

    生成*iterable*中的项，但从开头去掉*pred*返回``True``的项。
    例如，要从可迭代对象的开头删除一组项:
        >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
        >>> pred = lambda x: x in {None, False, ''}
        >>> list(lstrip(iterable, pred))
        [1, 2, None, 3, False, None]
    此函数类似于 :func:`str.lstrip`，本质上是 :func:`itertools.dropwhile` 的包装。

🌿33 make_decorator(wrapping_func, result_index=0)

make_decorator(wrapping_func, result_index=0), module=setuptools._vendor.more_itertools.more, line:2760 at site-packages\setuptools_vendor\more_itertools\more.py

返回 *wrapping_func* 的装饰器版本，这是一个修改可迭代对象的函数。
    *wrapping_func* 是该函数签名中可迭代对象所在的位置。
    这使您可以在“生产端”，即在函数定义中使用itertools。
    这可以在不更改函数代码的情况下增加函数返回的内容。例如，要生成:func:`chunked`的装饰器版本:
        >>> from more_itertools import chunked
        >>> chunker = make_decorator(chunked, result_index=0)
        >>> @chunker(3)
        ... def iter_range(n):
        ...     return iter(range(n))
        ...
        >>> list(iter_range(9))
        [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
    只允许返回真值项:
        >>> truth_serum = make_decorator(filter, result_index=1)
        >>> @truth_serum(bool)
        ... def boolean_test():
        ...     return [0, 1, '',``, False, True]
        ...
        >>> list(boolean_test())
        [1,``, True]
    :func:`peekable` 和 :func:`seekable` 包装器为实用装饰器:
        >>> from more_itertools import peekable
        >>> peekable_function = make_decorator(peekable)
        >>> @peekable_function()
        ... def str_range(*args):
        ...     return (str(x) for x in range(*args))
        ...
        >>> it = str_range(1, 20, 2)
        >>> next(it), next(it), next(it)
        ('1', '3', '5')
        >>> it.peek()
        '7'
        >>> next(it)
        '7'

🌿34 map_except(function, iterable, *exceptions)

map_except(function, iterable, *exceptions), module=setuptools._vendor.more_itertools.more, line:3259 at site-packages\setuptools_vendor\more_itertools\more.py

    用*function*转换*iterable*中的每个项并产生结果，除非*function*引发指定的*异常之一。
    调用*函数*来转换*iterable*中的每个项。它应该是一个可接受的参数。
        >>> iterable = ['1', '2', 'three', '4', None]
        >>> list(map_except(int, iterable, ValueError, TypeError))
        [1, 2, 4]
    如果由*function*引发的异常不是由*exceptions*给出的异常，则会像正常一样引发。

🌿35 map_reduce(iterable, keyfunc, valuefunc=None, reducefunc=None)

map_reduce(iterable, keyfunc, valuefunc=None, reducefunc=None), module=setuptools._vendor.more_itertools.more, line:2825 at site-packages\setuptools_vendor\more_itertools\more.py

返回一个字典，将*iterable*中的项映射到*keyfunc*定义的类别，用*valuefunc*对它们进行转换，然后用*reducefunc*按类别汇总它们。
    如果未指定，*valuefunc*默认为identity函数。
    如果* reducefunc *不明,没有总结发生:
        >>> keyfunc = lambda x: x.upper()
        >>> result = map_reduce('abbccc', keyfunc)
        >>> sorted(result.items())
        [('A', ['a']), ('B', ['b', 'b']), ('C', ['c', 'c', 'c'])]
    指定*valuefunc*对分类项进行转换:
        >>> keyfunc = lambda x: x.upper()
        >>> valuefunc = lambda x: 1
        >>> result = map_reduce('abbccc', keyfunc, valuefunc)
        >>> sorted(result.items())
        [('A', [1]), ('B', [1, 1]), ('C', [1, 1, 1])]
    指定*reducefunc*总结分类项目:
        >>> keyfunc = lambda x: x.upper()
        >>> valuefunc = lambda x: 1
        >>> reducefunc = sum
        >>> result = map_reduce('abbccc', keyfunc, valuefunc, reducefunc)
        >>> sorted(result.items())
        [('A', 1), ('B', 2), ('C', 3)]
    在应用map/reduce过程之前，您可能需要过滤输入的可迭代对象:
        >>> all_items = range(30)
        >>> items = [x for x in all_items if 10 <= x <= 20]  # Filter
        >>> keyfunc = lambda x: x % 2  # Evens map to 0; odds to 1
        >>> categories = map_reduce(items, keyfunc=keyfunc)
        >>> sorted(categories.items())
        [(0, [10, 12, 14, 16, 18, 20]), (1, [11, 13, 15, 17, 19])]
        >>> summaries = map_reduce(items, keyfunc=keyfunc, reducefunc=sum)
        >>> sorted(summaries.items())
        [(0, 90), (1, 75)]
    注意，在汇总步骤之前，可迭代对象中的所有项都被收集到一个列表中，这可能需要大量的存储空间。
    返回的对象是 :obj:`collections.defaultdict`， ``default_factory`` 被设置为`None``，这样它的行为就像一个普通的字典。

🌿36 nth_or_last(iterable, n, default=<object object at 0x000002830651A4A0>)

nth_or_last(iterable, n, default=<object object at 0x000002830651A4A0>), module=setuptools._vendor.more_itertools.more, line:217 at site-packages\setuptools_vendor\more_itertools\more.py

返回*iterable*的第n项或最后一项，如果*iterable*为空则返回*default*。
        >>> nth_or_last([0, 1, 2, 3], 2)
        2
        >>> nth_or_last([0, 1], 2)
        1
        >>> nth_or_last([], 0, 'some default')
        'some default'
    如果未提供*default*且可迭代对象中没有项，则引发``ValueError``。

🌿37 nth_permutation(iterable, r, index)

nth_permutation(iterable, r, index), module=setuptools._vendor.more_itertools.more, line:3630 at site-packages\setuptools_vendor\more_itertools\more.py

    相当于``list(permutations(iterable, r))[index] ``
    长度为*r*的*iterable*的子序列，其中顺序很重要，可以按字典顺序排序。
        >>> nth_permutation('ghijk', 2, 5)
        ('h', 'i')
    如果*r*为负值或大于*iterable*的长度，将引发ValueError。
    如果给定的*索引*无效，将引发' IndexError``。

🌿38 nth_product(index, *args)

nth_product(index, *args), module=setuptools._vendor.more_itertools.more, line:3599 at site-packages\setuptools_vendor\more_itertools\more.py

    相当于``list(product(*args))[index]``。
    *args*的乘积可以按字典顺序排序。
    :func:'nth_product'计算排序位置*index*的乘积，而不计算之前的乘积。
        >>> nth_product(8, range(2), range(2), range(2), range(2))
        (1, 0, 0, 0)
    如果给定的*索引*无效，将引发' IndexError``。

🌿39 one(iterable, too_short=None, too_long=None)

one(iterable, too_short=None, too_long=None), module=setuptools._vendor.more_itertools.more, line:514 at site-packages\setuptools_vendor\more_itertools\more.py

返回*iterable*中的第一项，预计只包含该项。
    如果*iterable*为空或包含多个项目，则引发异常。
    :func:`one` 用于确保可迭代对象仅包含一个项。
    例如，它可用于检索预期返回单行的数据库查询的结果。
    如果*iterable*为空，将引发``ValueError``。
    你可以用*too short*关键字指定一个不同的异常:
        >>> it = []
        >>> one(it)  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        ValueError: too many items in iterable (expected 1)'
        >>> too_short = IndexError('too few items')
        >>> one(it, too_short=too_short)  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        IndexError: too few items
    类似地，如果*iterable*包含多个项目，``ValueError``将被引发。你可以用关键字*too long*指定一个不同的异常:
        >>> it = ['too', 'many']
        >>> one(it)  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        ValueError: Expected exactly one item in iterable, but got 'too',
        'many', and perhaps more.
        >>> too_long = RuntimeError
        >>> one(it, too_long=too_long)  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        RuntimeError
    注意 :func:`one` 试图将*iterable*推进两次以确保只有一个项。
    请参阅 :func:`spy` 或 :func:`peekable` 以较少破坏性地检查可迭代内容。

🌿40 only(iterable, default=None, too_long=None)

only(iterable, default=None, too_long=None), module=setuptools._vendor.more_itertools.more, line:3117 at site-packages\setuptools_vendor\more_itertools\more.py

    如果*iterable*只有一个元素，返回它。
    如果它没有项，则返回*default*。
    如果它有多个项目，则引发*too_long*给出的异常，默认情况下为``ValueError``。
        >>> only([], default='missing')
        'missing'
        >>> only([1])
        1
        >>> only([1, 2])  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        ValueError: Expected exactly one item in iterable, but got 1, 2,
         and perhaps more.'
        >>> only([1, 2], too_long=TypeError)  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        TypeError
    注意 :func:`only` 尝试将*iterable*推进两次以确保只有一个项。
    请参阅 :func:`spy` 或 :func:`peekable` 以较少破坏性地检查可迭代内容。

🌿41 padded(iterable, fillvalue=None, n=None, next_multiple=False)

padded(iterable, fillvalue=None, n=None, next_multiple=False), module=setuptools._vendor.more_itertools.more, line:1368 at site-packages\setuptools_vendor\more_itertools\more.py

    产生来自*iterable*的元素，后面跟着*fillvalue*，这样至少会发出*n*项。
        >>> list(padded([1, 2, 3], '?', 5))
        [1, 2, 3, '?', '?']
    如果*下一个倍数*为``True``，则将发出*fillvalue*，直到发出的项数是*n*:
        >>> list(padded([1, 2, 3, 4], n=3, next_multiple=True))
        [1, 2, 3, 4, None, None]
    如果*n*为``None``，则将无限发出*fillvalue*。

🌿42 partitions(iterable)

partitions(iterable), module=setuptools._vendor.more_itertools.more, line:2996 at site-packages\setuptools_vendor\more_itertools\more.py

    生成*iterable*的所有可能的保序分区。
        >>> iterable = 'abc'
        >>> for part in partitions(iterable):
        ...     print([''.join(p) for p in part])
        ['abc']
        ['a', 'bc']
        ['ab', 'c']
        ['a', 'b', 'c']
    这与 :func:`partition`无关。

🌿43 set_partitions(iterable, k=None)

set_partitions(iterable, k=None), module=setuptools._vendor.more_itertools.more, line:3016 at site-packages\setuptools_vendor\more_itertools\more.py

    将*iterable*的集合分区分成*k*个部分。集合分区不保持顺序。
        >>> iterable = 'abc'
        >>> for part in set_partitions(iterable, 2):
        ...     print([''.join(p) for p in part])
        ['a', 'bc']
        ['ab', 'c']
        ['b', 'ac']
    如果*k*未给定，则生成每个集合分区。
        >>> iterable = 'abc'
        >>> for part in set_partitions(iterable):
        ...     print([''.join(p) for p in part])
        ['abc']
        ['a', 'bc']
        ['ab', 'c']
        ['b', 'ac']
        ['a', 'b', 'c']

🌿44 repeat_last(iterable, default=None)

repeat_last(iterable, default=None), module=setuptools._vendor.more_itertools.more, line:1400 at site-packages\setuptools_vendor\more_itertools\more.py

    在*iterable*耗尽后，继续输出它的最后一个元素。
        >>> list(islice(repeat_last(range(3)), 5))
        [0, 1, 2, 2, 2]
    如果可迭代对象为空，则yield *default* forever:
        >>> list(islice(repeat_last(range(0), 42), 5))
        [42, 42, 42, 42, 42]

🌿45 replace(iterable, pred, substitutes, count=None, window_size=1)

replace(iterable, pred, substitutes, count=None, window_size=1), module=setuptools._vendor.more_itertools.more, line:2935 at site-packages\setuptools_vendor\more_itertools\more.py

    生成*iterable*中的项，将*pred*返回``True``的项替换为*iterable*替代的项。
        >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1]
        >>> pred = lambda x: x == 0
        >>> substitutes = (2, 3)
        >>> list(replace(iterable, pred, substitutes))
        [1, 1, 2, 3, 1, 1, 2, 3, 1, 1]
    如果给出了*count*，则替换的数量将受到限制:
        >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1, 0]
        >>> pred = lambda x: x == 0
        >>> substitutes = [None]
        >>> list(replace(iterable, pred, substitutes, count=2))
        [1, 1, None, 1, 1, None, 1, 1, 0]
    使用*窗口大小*来控制作为参数传递给*pred*的项的数量。这允许定位和替换子序列。
        >>> iterable = [0, 1, 2, 5, 0, 1, 2, 5]
        >>> window_size = 3
        >>> pred = lambda *args: args == (0, 1, 2)  # 3 items passed to pred
        >>> substitutes = [3, 4] # Splice in these items
        >>> list(replace(iterable, pred, substitutes, window_size=window_size))
        [3, 4, 5, 3, 4, 5]

🌿46 rlocate(iterable, pred=<class ‘bool’>, window_size=None)

rlocate(iterable, pred=<class ‘bool’>, window_size=None), module=setuptools._vendor.more_itertools.more, line:2892 at site-packages\setuptools_vendor\more_itertools\more.py

    生成*iterable*中*pred*返回``True``的每个项的索引，从右开始向左移动。
    *pred*默认为 :func:`bool` ，它将选择真值项:
        >>> list(rlocate([0, 1, 1, 0, 1, 0, 0]))  # Truthy at 1, 2, and 4
        [4, 2, 1]
    设置*pred*为自定义函数，例如，查找特定项的索引:
        >>> iterable = iter('abcb')
        >>> pred = lambda x: x == 'b'
        >>> list(rlocate(iterable, pred))
        [3, 1]
    如果给出了*窗口大小*，那么将调用*pred*函数，并调用这么多项。这允许搜索子序列:
        >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
        >>> pred = lambda *args: args == (1, 2, 3)
        >>> list(rlocate(iterable, pred=pred, window_size=3))
        [9, 5, 1]
    如果*iterable*是可逆的，``rlocate``将反转它并从右搜索。
    否则，它将从左边开始搜索，并以相反的顺序返回结果。
    请参阅 :func:`locate` 了解其他示例应用程序。

🌿47 rstrip(iterable, pred)

rstrip(iterable, pred), module=setuptools._vendor.more_itertools.more, line:2225 at site-packages\setuptools_vendor\more_itertools\more.py

    生成*iterable*中的项，但从*pred*返回``True``的末尾删除任何项。
    例如，要从可迭代对象的末尾删除一组项:
        >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
        >>> pred = lambda x: x in {None, False, ''}
        >>> list(rstrip(iterable, pred))
        [None, False, None, 1, 2, None, 3]
    此函数类似于 :func:`str.rstrip`。

🌿48 sample(iterable, k, weights=None)

sample(iterable, k, weights=None), module=setuptools._vendor.more_itertools.more, line:3341 at site-packages\setuptools_vendor\more_itertools\more.py

    返回一个长度为*k*的从*可迭代对象*中选择(不替换)的元素列表。
    如 :func:`random.sample`，但适用于未知长度的可迭代对象。
        >>> iterable = range(100)
        >>> sample(iterable, 5)  # doctest: +SKIP
        [81, 60, 96, 16, 4]
    也可以给出具有*weights*的可迭代对象:
        >>> iterable = range(100)
        >>> weights = (i * i + 1 for i in range(100))
        >>> sampled = sample(iterable, 5, weights=weights)  # doctest: +SKIP
        [79, 67, 74, 66, 78]
    该算法还可用于生成加权随机排列。每个项目的相对权重决定了它在排列中出现较晚的概率。
        >>> data = "abcdefgh"
        >>> weights = range(1, len(data) + 1)
        >>> sample(data, k=len(data), weights=weights)  # doctest: +SKIP
        ['c', 'a', 'b', 'e', 'g', 'd', 'h', 'f']

🌿49 side_effect(func, iterable, chunk_size=None, before=None, after=None)

side_effect(func, iterable, chunk_size=None, before=None, after=None), module=setuptools._vendor.more_itertools.more, line:1068 at site-packages\setuptools_vendor\more_itertools\more.py

在生成项之前，对*iterable*中的每个项调用*func*(或对每个*块大小*组的项)。
    `func`必须是一个接受单个参数的函数。它的返回值将被丢弃。
    *before*和*after*是不带参数的可选函数。
    它们将分别在迭代开始前和迭代结束后执行。
    `side_effect` 可用于日志记录、更新进度条或任何功能上不"pure."的东西。
    发出状态消息:
        >>> from more_itertools import consume
        >>> func = lambda item: print('Received {}'.format(item))
        >>> consume(side_effect(func, range(2)))
        Received 0
        Received 1
    对大块物品进行操作的:
        >>> pair_sums = []
        >>> func = lambda chunk: pair_sums.append(sum(chunk))
        >>> list(side_effect(func, [0, 1, 2, 3, 4, 5], 2))
        [0, 1, 2, 3, 4, 5]
        >>> list(pair_sums)
        [1, 5, 9]
    写入一个类文件对象:
        >>> from io import StringIO
        >>> from more_itertools import consume
        >>> f = StringIO()
        >>> func = lambda x: print(x, file=f)
        >>> before = lambda: print(u'HEADER', file=f)
        >>> after = f.close
        >>> it = [u'a', u'b', u'c']
        >>> consume(side_effect(func, it, before=before, after=after))
        >>> f.closed
        True

🌿50 sliced(seq, n, strict=False)

sliced(seq, n, strict=False), module=setuptools._vendor.more_itertools.more, line:1129 at site-packages\setuptools_vendor\more_itertools\more.py

    从序列*seq*中产生长度*n*的切片。
        >>> list(sliced((1, 2, 3, 4, 5, 6), 3))
        [(1, 2, 3), (4, 5, 6)]
    默认情况下，如果*seq*的长度不能被*n*整除，则最后生成的切片的元素数将少于*n*个:
        >>> list(sliced((1, 2, 3, 4, 5, 6, 7, 8), 3))
        [(1, 2, 3), (4, 5, 6), (7, 8)]
    如果*seq*的长度是不整除*n* *strict* 和 ``True`` ,那么“ValueError“将提高之前最后一块了。
    此函数仅适用于支持切片的可迭代对象。对于不可切片的可迭代对象，请参见 :func:`chunked`。

🌿51 sort_together(iterables, key_list=(0,), key=None, reverse=False)

sort_together(iterables, key_list=(0,), key=None, reverse=False), module=setuptools._vendor.more_itertools.more, line:1586 at site-packages\setuptools_vendor\more_itertools\more.py

返回排序在一起的输入可迭代对象，以*key list*作为排序的优先级。
    所有可迭代对象都被裁剪为最短对象的长度。这可以像电子表格中的排序函数一样使用。
    如果每个可迭代对象表示一列数据，则键列表决定使用哪些列进行排序。
    默认情况下，所有可迭代对象都使用``0``-th iterable:
        >>> iterables = [(4, 3, 2, 1), ('a', 'b', 'c', 'd')]
        >>> sort_together(iterables)
        [(1, 2, 3, 4), ('d', 'c', 'b', 'a')]
    设置一个不同的键列表，根据另一个可迭代对象进行排序。指定多个键指示关系如何被打破:
        >>> iterables = [(3, 1, 2), (0, 1, 0), ('c', 'b', 'a')]
        >>> sort_together(iterables, key_list=(1, 2))
        [(2, 3, 1), (0, 0, 1), ('a', 'c', 'b')]
    要按可迭代对象元素的函数排序，传递一个*key*函数。它的参数是键列表对应的可迭代对象的元素:
        >>> names = ('a', 'b', 'c')
        >>> lengths = (1, 2, 3)
        >>> widths = (5, 2, 1)
        >>> def area(length, width):
        ...     return length * width
        >>> sort_together([names, lengths, widths], key_list=(1, 2), key=area)
        [('c', 'b', 'a'), (3, 2, 1), (1, 2, 5)]
    设置*reverse*为``True``，按降序排序。
        >>> sort_together([(1, 2, 3), ('c', 'b', 'a')], reverse=True)
        [(3, 2, 1), ('a', 'b', 'c')]

🌿52 split_at(iterable, pred, maxsplit=-1, keep_separator=False)

split_at(iterable, pred, maxsplit=-1, keep_separator=False), module=setuptools._vendor.more_itertools.more, line:1163 at site-packages\setuptools_vendor\more_itertools\more.py

    生成来自*iterable*的项目列表，其中每个列表由一个项目分隔，其中callable *pred*返回``True``。
        >>> list(split_at('abcdcba', lambda x: x == 'b'))
        [['a'], ['c', 'd', 'c'], ['a']]
        >>> list(split_at(range(10), lambda n: n % 2 == 1))
        [[0], [2], [4], [6], [8], []]
    最多*maxsplit*分裂完成。
    如果*maxsplit*未指定或为-1，则对分割次数没有限制:
        >>> list(split_at(range(10), lambda n: n % 2 == 1, maxsplit=2))
        [[0], [2], [4, 5, 6, 7, 8, 9]]
    默认情况下，分隔项不包括在输出中。包括它们，设置 *keep_separator* 为``True``。
        >>> list(split_at('abcdcba', lambda x: x == 'b', keep_separator=True))
        [['a'], ['b'], ['c', 'd', 'c'], ['b'], ['a']]

🌿53 split_after(iterable, pred, maxsplit=-1)

split_after(iterable, pred, maxsplit=-1), module=setuptools._vendor.more_itertools.more, line:1242 at site-packages\setuptools_vendor\more_itertools\more.py

    从*iterable*中生成项目列表，其中每个列表以一个项目结束，其中callable *pred*返回``True``:
        >>> list(split_after('one1two2', lambda s: s.isdigit()))
        [['o', 'n', 'e', '1'], ['t', 'w', 'o', '2']]
        >>> list(split_after(range(10), lambda n: n % 3 == 0))
        [[0], [1, 2, 3], [4, 5, 6], [7, 8, 9]]
    最多进行*maxsplit*分割。如果*maxsplit*未指定或为-1，则拆分次数没有限制:
        >>> list(split_after(range(10), lambda n: n % 3 == 0, maxsplit=2))
        [[0], [1, 2, 3], [4, 5, 6, 7, 8, 9]]

🌿54 split_before(iterable, pred, maxsplit=-1)

split_before(iterable, pred, maxsplit=-1), module=setuptools._vendor.more_itertools.more, line:1207 at site-packages\setuptools_vendor\more_itertools\more.py

    从*iterable*中生成项目列表，其中每个列表在一个项目之前结束，callable *pred*返回``True``:
        >>> list(split_before('OneTwo', lambda s: s.isupper()))
        [['O', 'n', 'e'], ['T', 'w', 'o']]
        >>> list(split_before(range(10), lambda n: n % 3 == 0))
        [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]
    最多进行*maxsplit*拆分。如果*maxsplit*未指定或为-1，则拆分次数没有限制:
        >>> list(split_before(range(10), lambda n: n % 3 == 0, maxsplit=2))
        [[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]]

🌿55 split_when(iterable, pred, maxsplit=-1)

split_when(iterable, pred, maxsplit=-1), module=setuptools._vendor.more_itertools.more, line:1278 at site-packages\setuptools_vendor\more_itertools\more.py

    根据*pred*的输出将*iterable*拆分为几个部分。
    *pred*应该是一个函数，它接受连续的项目对，如果可迭代对象应该在它们之间分割，则返回``True``。
    例如，要查找不断增加的数字，当元素``i``大于元素``' i + 1``时拆分可迭代对象:
        >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2], lambda x, y: x > y))
        [[1, 2, 3, 3], [2, 5], [2, 4], [2]]
    最多执行*maxsplit*次拆分。如果*maxsplit*未指定或为-1，则对拆分的数量没有限制:
        >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2],
        ...                 lambda x, y: x > y, maxsplit=2))
        [[1, 2, 3, 3], [2, 5], [2, 4, 2]]

🌿56 split_into(iterable, sizes)

split_into(iterable, sizes), module=setuptools._vendor.more_itertools.more, line:1323 at site-packages\setuptools_vendor\more_itertools\more.py

    从*iterable*中为*size *中的每个整数'n'生成一个长度为'n'的顺序项列表。
        >>> list(split_into([1,2,3,4,5,6], [1,2,3]))
        [[1], [2, 3], [4, 5, 6]]
    如果*size *的总和小于*iterable*的长度，则*iterable*的剩余项将不被返回。
        >>> list(split_into([1,2,3,4,5,6], [2,3]))
        [[1, 2], [3, 4, 5]]
    如果*size *的总和大于*iterable*的长度，则在超出*iterable*的迭代中返回的项目将更少，并且进一步的列表将为空:
        >>> list(split_into([1,2,3,4], [1,2,3,4]))
        [[1], [2, 3], [4], []]
    当在*size *中遇到``None``对象时，返回的列表将包含到*iterable*末尾的项目，与itertools相同。
        >>> list(split_into([1,2,3,4,5,6,7,8,9,0], [2,3,None]))
        [[1, 2], [3, 4, 5], [6, 7, 8, 9, 0]]
    :func:`split_into` 对于分组大小不一致的一系列项目非常有用。
    例如，在表的一行中，多个列表示相同特征的元素(例如，由x,y,z表示的点)，但是，格式并不是所有列都相同。

🌿57 spy(iterable, n=1)

spy(iterable, n=1), module=setuptools._vendor.more_itertools.more, line:947 at site-packages\setuptools_vendor\more_itertools\more.py

    返回一个2元组，其中包含*iterable*的前*n*个元素，以及一个具有与*iterable*相同元素的迭代器。
    这允许你“提前查看”可迭代对象中的项，而无需推进它。列表中默认有一个项目:
        >>> iterable = 'abcdefg'
        >>> head, iterable = spy(iterable)
        >>> head
        ['a']
        >>> list(iterable)
        ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    您可以使用解包来检索项目而不是列表:
        >>> (head,), iterable = spy('abcdefg')
        >>> head
        'a'
        >>> (first, second), iterable = spy('abcdefg', 2)
        >>> first
        'a'
        >>> second
        'b'
    请求的项数可以大于可迭代对象中的项数:
        >>> iterable = [1, 2, 3, 4, 5]
        >>> head, iterable = spy(iterable, 10)
        >>> head
        [1, 2, 3, 4, 5]
        >>> list(iterable)
        [1, 2, 3, 4, 5]

🌿58 stagger(iterable, offsets=(-1, 0, 1), longest=False, fillvalue=None)

stagger(iterable, offsets=(-1, 0, 1), longest=False, fillvalue=None), module=setuptools._vendor.more_itertools.more, line:1454 at site-packages\setuptools_vendor\more_itertools\more.py

    生成元素偏移于*iterable*的元组。每个元组中`i`项的偏移量由*offsets*中的`i`项给出。
        >>> list(stagger([0, 1, 2, 3]))
        [(None, 0, 1), (0, 1, 2), (1, 2, 3)]
        >>> list(stagger(range(8), offsets=(0, 2, 4)))
        [(0, 2, 4), (1, 3, 5), (2, 4, 6), (3, 5, 7)]
    默认情况下，当元组的最后一个元素是可迭代对象中的最后一项时，序列将结束。
    要继续直到元组的第一个元素是可迭代对象中的最后一个元素，请将*longest*设置为``True``:
        >>> list(stagger([0, 1, 2, 3], longest=True))
        [(None, 0, 1), (0, 1, 2), (1, 2, 3), (2, 3, None), (3, None, None)]
    默认情况下，``None``将用于替换序列末尾以外的偏移量。指定*fillvalue*以使用其他值。

🌿59 strip(iterable, pred)

strip(iterable, pred), module=setuptools._vendor.more_itertools.more, line:2251 at site-packages\setuptools_vendor\more_itertools\more.py

    生成*iterable*中的项，但从*pred*返回``True``的开始和结束处删除任何项。
    例如，要从可迭代对象的两端移除一组元素:
        >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
        >>> pred = lambda x: x in {None, False, ''}
        >>> list(strip(iterable, pred))
        [1, 2, None, 3]
    此函数类似于 :func:`str.strip`.。

🌿60 substrings(iterable)

substrings(iterable), module=setuptools._vendor.more_itertools.more, line:791 at site-packages\setuptools_vendor\more_itertools\more.py

    生成*iterable*的所有子字符串。
        >>> [''.join(s) for s in substrings('more')]
        ['m', 'o', 'r', 'e', 'mo', 'or', 're', 'mor', 'ore', 'more']
    注意，非字符串可迭代对象也可以细分。
        >>> list(substrings([0, 1, 2]))
        [(0,), (1,), (2,), (0, 1), (1, 2), (0, 1, 2)]

🌿61 substrings_indexes(seq, reverse=False)

substrings_indexes(seq, reverse=False), module=setuptools._vendor.more_itertools.more, line:817 at site-packages\setuptools_vendor\more_itertools\more.py

    生成的项将是一个形式为``(substr, i, j)``的元组，其中``substr = seq[i:j]``。
    此函数仅适用于支持切片的可迭代对象，例如``str``对象。
    >>> for item in substrings_indexes('more'):
    ...    print(item)
    ('m', 0, 1)
    ('o', 1, 2)
    ('r', 2, 3)
    ('e', 3, 4)
    ('mo', 0, 2)
    ('or', 1, 3)
    ('re', 2, 4)
    ('mor', 0, 3)
    ('ore', 1, 4)
    ('more', 0, 4)
    将*reverse*设置为``True`` ，以产生顺序相反的相同项。

🌿62 unique_to_each(*iterables)

unique_to_each(*iterables), module=setuptools._vendor.more_itertools.more, line:707 at site-packages\setuptools_vendor\more_itertools\more.py

    返回每个输入可迭代对象中不在其他输入可迭代对象中的元素。
    例如，假设您有一组软件包，每个软件包都有一组依赖项:
        {'pkg_1': {'A', 'B'}, 'pkg_2': {'B', 'C'}, 'pkg_3': {'B', 'D'}}
    如果您删除了一个软件包，哪些依赖项也可以删除?
    如果删除``pkg_1``，则不再需要``A ``-它与``pkg_2``或``pkg_3``无关。
    类似地，“C”只需要用于``pkg_2``，和``D``只需要``pkg_3```:
        >>> unique_to_each({'A', 'B'}, {'B', 'C'}, {'B', 'D'})
        [['A'], ['C'], ['D']]
    如果在一个输入可迭代对象中有重复的，而在其他可迭代对象中没有重复的，它们将在输出中重复。输入顺序是保留的:
        >>> unique_to_each("mississippi", "missouri")
        [['p', 'p'], ['o', 'u', 'r']]
    假设每个可迭代对象的元素都是可哈希的。

🌿63 unzip(iterable)

unzip(iterable), module=setuptools._vendor.more_itertools.more, line:1652 at site-packages\setuptools_vendor\more_itertools\more.py

    作为 :func:`zip` 的逆函数，此函数分解压缩后的*iterable*的元素。
    “i”-可迭代对象包含“i”-可迭代对象中每个元素的元素。第一个元素用于确定剩余元素的长度。
        >>> iterable = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
        >>> letters, numbers = unzip(iterable)
        >>> list(letters)
        ['a', 'b', 'c', 'd']
        >>> list(numbers)
        [1, 2, 3, 4]
    这类似于使用``zip(*iterable)``，但它避免了将*iterable*读取到内存中。
    但是请注意，这个函数使用:func:`itertools。因此可能需要大量的存储空间。

🌿64 windowed(seq, n, fillvalue=None, step=1)

windowed(seq, n, fillvalue=None, step=1), module=setuptools._vendor.more_itertools.more, line:740 at site-packages\setuptools_vendor\more_itertools\more.py

    在给定的可迭代对象上返回一个宽度为*n*的滑动窗口。
        >>> all_windows = windowed([1, 2, 3, 4, 5], 3)
        >>> list(all_windows)
        [(1, 2, 3), (2, 3, 4), (3, 4, 5)]
    当窗口大于可迭代对象时，*fillvalue*被用来代替缺失的值:
        >>> list(windowed([1, 2, 3], 4))
        [(1, 2, 3, None)]
    每个窗口将以*step*的增量前进:
        >>> list(windowed([1, 2, 3, 4, 5, 6], 3, fillvalue='!', step=2))
        [(1, 2, 3), (3, 4, 5), (5, 6, '!')]
    要滑入可迭代对象的项，使用 :func:`chain` 在左侧添加填充项:
        >>> iterable = [1, 2, 3, 4]
        >>> n = 3
        >>> padding = [None] * (n - 1)
        >>> list(windowed(chain(padding, iterable), 3))
        [(None, None, 1), (None, 1, 2), (1, 2, 3), (2, 3, 4)]

🌿65 with_iter(context_manager)

with_iter(context_manager), module=setuptools._vendor.more_itertools.more, line:499 at site-packages\setuptools_vendor\more_itertools\more.py

    将可迭代对象包装在``with``语句中，这样它就会在耗尽后关闭。
    例如，这将在迭代器耗尽时关闭文件:
        upper_lines = (line.upper() for line in with_iter(open('foo')))
    任何返回可迭代对象的上下文管理器都是``with_iter``的候选者。

🌿66 zip_equal(*iterables)

zip_equal(*iterables), module=setuptools._vendor.more_itertools.more, line:1501 at site-packages\setuptools_vendor\more_itertools\more.py

``zip ``将输入的*可迭代对象*放在一起，但如果它们的长度不相同，则引发``UnequalIterablesError``。
        >>> it_1 = range(3)
        >>> it_2 = iter('abc')
        >>> list(zip_equal(it_1, it_2))
        [(0, 'a'), (1, 'b'), (2, 'c')]
        >>> it_1 = range(3)
        >>> it_2 = iter('abcd')
        >>> list(zip_equal(it_1, it_2)) # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        more_itertools.more.UnequalIterablesError: Iterables 具有不同长度。

🌿67 zip_offset(*iterables, offsets, longest=False, fillvalue=None)

zip_offset(*iterables, offsets, longest=False, fillvalue=None), module=setuptools._vendor.more_itertools.more, line:1547 at site-packages\setuptools_vendor\more_itertools\more.py

    将输入的*可迭代对象*“压缩”在一起，但将*偏移量*中的`i`项偏移`i` -可迭代对象。
        >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1)))
        [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e')]
    这可以用作SciPy或pandas的轻量级替代品，用于分析某些序列具有领先或滞后关系的数据集。
    默认情况下，序列将在最短可迭代对象耗尽时结束。要继续直到最长可迭代对象耗尽，请将*longest*设置为``True``。
        >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1), longest=True))
        [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e'), (None, 'f')]
    默认情况下，' ' None ' ' '将用于替换超出序列末尾的偏移量。指定*fillvalue*以使用其他值。

🌿68 windowed_complete(iterable, n)

windowed_complete(iterable, n), module=setuptools._vendor.more_itertools.more, line:3524 at site-packages\setuptools_vendor\more_itertools\more.py

    生成 ``(beginning, middle, end)``  元组，其中:
        * 每个 ``middle`` 有*n* 项来自*iterable*
        * 每个 ``beginning`` 在``middle``之前的项有**项。
        * 每个 ``end``在``middle``之后的项有**项。
        >>> iterable = range(7)
        >>> n = 3
        >>> for beginning, middle, end in windowed_complete(iterable, n):
        ...     print(beginning, middle, end)
        () (0, 1, 2) (3, 4, 5, 6)
        (0,) (1, 2, 3) (4, 5, 6)
        (0, 1) (2, 3, 4) (5, 6)
        (0, 1, 2) (3, 4, 5) (6,)
        (0, 1, 2, 3) (4, 5, 6) ()
    注意*n*必须至少为0并且最等于*iterable*的长度。此函数将耗尽可迭代对象，并且可能需要大量存储空间。

🌿69 all_unique(iterable, key=None)

all_unique(iterable, key=None), module=setuptools._vendor.more_itertools.more, line:3564 at site-packages\setuptools_vendor\more_itertools\more.py

    如果*iterable*的所有元素都是唯一的(没有两个元素相等)，则返回' True``。
        >>> all_unique('ABCB')
        False
    如果指定了一个*key*函数，它将用于进行比较。
        >>> all_unique('ABCb')
        True
        >>> all_unique('ABCb', str.lower)
        False
    函数在遇到第一个非唯一元素时立即返回。
    可以使用混合了哈希和不可哈希项的Iterables，但对于不可哈希项，该函数会变慢。

🌿70 value_chain(*args)

value_chain(*args), module=setuptools._vendor.more_itertools.more, line:3676 at site-packages\setuptools_vendor\more_itertools\more.py

    按照传递给函数的顺序，生成传递给函数的所有参数。
    如果参数本身是可迭代的，则迭代其值。
        >>> list(value_chain(1, 2, 3, [4, 5, 6]))
        [1, 2, 3, 4, 5, 6]
    二进制字符串和文本字符串不被认为是可迭代的，并按原样发出:
        >>> list(value_chain('12', '34', ['56', '78']))
        ['12', '34', '56', '78']
    多个嵌套级别不会被扁平化。

🌿71 product_index(element, *args)

product_index(element, *args), module=setuptools._vendor.more_itertools.more, line:3704 at site-packages\setuptools_vendor\more_itertools\more.py

    相当于``list(product(*args)).index(element) ``
    *args*的乘积可以按字典顺序排序。
    :func:`product_index` 计算*element*的第一个索引，而不计算前面的产品。
        >>> product_index([8, 2], range(10), range(5))
        42
    如果给定的*元素*不在*args*的乘积中，将引发' ValueError``。

🌿72 combination_index(element, iterable)

combination_index(element, iterable), module=setuptools._vendor.more_itertools.more, line:3729 at site-packages\setuptools_vendor\more_itertools\more.py

    相当于``list(combination(iterable, r)).index(element)``
    长度为*r*的*iterable*的子序列可以按字典顺序排序。
    :func: '组合索引'计算第一个*元素*的索引，不计算前面的组合。
        >>> combination_index('adf', 'abcdefg')
        10
    如果给定的*元素*不是*iterable*的组合之一，将引发' ValueError``。

🌿73 permutation_index(element, iterable)

permutation_index(element, iterable), module=setuptools._vendor.more_itertools.more, line:3772 at site-packages\setuptools_vendor\more_itertools\more.py

    相当于``list(permutations(iterable, r)).index(element) ``
    长度为*r*的*iterable*的子序列，其中顺序很重要，可以按字典顺序排序。
    :func:'permutation_index'直接计算第一个元素的索引，而不计算前面的排列。
        >>> permutation_index([1, 3, 2], range(5))
        19
    如果给定的*元素*不是*iterable*的排列之一，则会引发``ValueError``。

🌿74 all_equal(iterable)

all_equal(iterable), module=setuptools._vendor.more_itertools.recipes, line:158 at site-packages\setuptools_vendor\more_itertools\recipes.py

如果所有元素彼此相等，则返回“True”。
        >>> all_equal('aaaa')
        True
        >>> all_equal('aaab')
        False

🌿75 consume(iterator, n=None)

consume(iterator, n=None), module=setuptools._vendor.more_itertools.recipes, line:105 at site-packages\setuptools_vendor\more_itertools\recipes.py

    将*可迭代*向前推进*n*步。如果*n*为``None``，则完全消耗它。
    有效地耗尽迭代器而不返回值。
    默认消耗整个迭代器，但可以提供第二个可选参数来限制消耗。
        >>> i = (x for x in range(10))
        >>> next(i)
        0
        >>> consume(i, 3)
        >>> next(i)
        4
        >>> consume(i)
        >>> next(i)
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        StopIteration
    如果迭代器的剩余项少于提供的限制，则整个迭代器将被消耗。
        >>> i = (x for x in range(3))
        >>> consume(i, 5)
        >>> next(i)
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module> StopIteration

🌿76 convolve(signal, kernel)

convolve(signal, kernel), module=setuptools._vendor.more_itertools.recipes, line:603 at site-packages\setuptools_vendor\more_itertools\recipes.py

    将可迭代*信号*与可迭代*内核*进行卷积。
        >>> signal = (1, 2, 3, 4, 5)
        >>> kernel = [3, 2, 1]
        >>> list(convolve(signal, kernel))
        [3, 8, 14, 20, 26, 14, 5]
    注意:输入参数是不可互换的，因为*kernel*会立即被消耗和存储。

🌿77 dotproduct(vec1, vec2)

dotproduct(vec1, vec2), module=setuptools._vendor.more_itertools.recipes, line:209 at site-packages\setuptools_vendor\more_itertools\recipes.py

返回两个可迭代对象的点积。
    >>> dotproduct([10, 10], [20, 20])
    400

🌿78 first_true(iterable, default=None, pred=None)

first_true(iterable, default=None, pred=None), module=setuptools._vendor.more_itertools.recipes, line:455 at site-packages\setuptools_vendor\more_itertools\recipes.py

    返回可迭代对象中的第一个真值。
    如果没有找到真值，则返回*default*如果*pred*不是None，则返回 ``pred(item) == True`` 的第一个项目。
        >>> first_true(range(10))
        1
        >>> first_true(range(10), pred=lambda x: x > 5)
        6
        >>> first_true(range(10), default='missing', pred=lambda x: x > 9)
        'missing'

🌿79 flatten(listOfLists)

flatten(listOfLists), module=setuptools._vendor.more_itertools.recipes, line:219 at site-packages\setuptools_vendor\more_itertools\recipes.py

    返回一个迭代器，在列表的列表中平坦化一层嵌套。
        >>> list(flatten([[0, 1], [2, 3]]))
        [0, 1, 2, 3]
    参见 :func:`collapse` ，它可以平铺多层嵌套。

🌿80 grouper(iterable, n, fillvalue=None)

grouper(iterable, n, fillvalue=None), module=setuptools._vendor.more_itertools.recipes, line:284 at site-packages\setuptools_vendor\more_itertools\recipes.py

将数据收集到固定长度的块或块。
    >>> list(grouper('ABCDEFG', 3, 'x'))
    [('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')]

🌿81 iter_except(func, exception, first=None)

iter_except(func, exception, first=None), module=setuptools._vendor.more_itertools.recipes, line:434 at site-packages\setuptools_vendor\more_itertools\recipes.py

反复从函数中获取结果，直到引发异常。将调用直到异常的接口转换为迭代器接口。
类似于``iter(func, sentinel)``，但使用异常而不是哨兵来结束循环。
        >>> l = [0, 1, 2]
        >>> list(iter_except(l.pop, IndexError))
        [2, 1, 0]

🌿82 ncycles(iterable, n)

ncycles(iterable, n), module=setuptools._vendor.more_itertools.recipes, line:199 at site-packages\setuptools_vendor\more_itertools\recipes.py

返回序列元素*n*。
    >>> list(ncycles(["a", "b"], 3))
    ['a', 'b', 'a', 'b', 'a', 'b']

🌿83 nth(iterable, n, default=None)

nth(iterable, n, default=None), module=setuptools._vendor.more_itertools.recipes, line:145 at site-packages\setuptools_vendor\more_itertools\recipes.py

返回第n项或默认值。
    >>> l = range(10)
    >>> nth(l, 3)
    3
    >>> nth(l, 20, "zebra")
    'zebra'

🌿84 nth_combination(iterable, r, index)

nth_combination(iterable, r, index), module=setuptools._vendor.more_itertools.recipes, line:546 at site-packages\setuptools_vendor\more_itertools\recipes.py

    相当于``list(combinations(iterable, r))[index]``。
    长度为*r*的*iterable*的子序列可以按字典顺序排序。
    :func:`nth_combination` 直接计算排序位置*index*的子序列，而不计算前面的子序列。
        >>> nth_combination(range(5), 3, 5)
        (0, 3, 4)
    如果*r*为负值或大于*iterable*的长度，将引发ValueError。
    如果给定的``IndexError`` 无效，将引发' IndexError``。

🌿85 pad_none(iterable)

pad_none(iterable), module=setuptools._vendor.more_itertools.recipes, line:182 at site-packages\setuptools_vendor\more_itertools\recipes.py

    返回元素序列，然后无限期返回``None``。
        >>> take(5, pad_none(range(3)))
        [0, 1, 2, None, None]
    用于模拟内置的 :func:`map` 函数的行为。参见:func:`padded`。

🌿86 pad_none(iterable)

pad_none(iterable), module=setuptools._vendor.more_itertools.recipes, line:182 at site-packages\setuptools_vendor\more_itertools\recipes.py

    返回元素序列，然后无限期返回``None``。
        >>> take(5, pad_none(range(3)))
        [0, 1, 2, None, None]
    用于模拟内置的 :func:`map` 函数的行为。参见 :func:`map`。

🌿87 _pairwise(iterable)

_pairwise(iterable), module=setuptools._vendor.more_itertools.recipes, line:258 at site-packages\setuptools_vendor\more_itertools\recipes.py

返回原始元素中重叠的成对元素的迭代器。
    >>> take(4, pairwise(count()))
    [(0, 1), (1, 2), (2, 3), (3, 4)]
    在Python 3.10及以上版本中，这是 :func:`itertools.pairwise` 的别名。

🌿88 partition(pred, iterable)

partition(pred, iterable), module=setuptools._vendor.more_itertools.recipes, line:323 at site-packages\setuptools_vendor\more_itertools\recipes.py

返回从输入可迭代对象派生的2元组可迭代对象。
    第一个生成具有``pred(item) = False``的项。
    第二个函数生成具有``pred(item) = True``的项。
        >>> is_odd = lambda x: x % 2 != 0
        >>> iterable = range(10)
        >>> even_items, odd_items = partition(is_odd, iterable)
        >>> list(even_items), list(odd_items)
        ([0, 2, 4, 6, 8], [1, 3, 5, 7, 9])
    如果 *pred* 为 None, 将使用 :func:`bool`。
        >>> iterable = [0, 1, False, True, '',``]
        >>> false_items, true_items = partition(None, iterable)
        >>> list(false_items), list(true_items)
        ([0, False, ''], [1, True,``])

🌿89 powerset(iterable)

powerset(iterable), module=setuptools._vendor.more_itertools.recipes, line:354 at site-packages\setuptools_vendor\more_itertools\recipes.py

生成可迭代对象的所有可能子集。
        >>> list(powerset([1, 2, 3]))
        [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
    :func:`powerset` 将操作非 :class:`set` 实例的可迭代对象，因此输入中的重复元素将在输出中产生重复元素。
    用 :func:`unique_everseen` 输入以避免产生重复:
        >>> seq = [1, 1, 0]
        >>> list(powerset(seq))
        [(), (1,), (1,), (0,), (1, 1), (1, 0), (1, 0), (1, 1, 0)]
        >>> from more_itertools import unique_everseen
        >>> list(powerset(unique_everseen(seq)))
        [(), (1,), (0,), (1, 0)]

🌿90 prepend(value, iterator)

prepend(value, iterator), module=setuptools._vendor.more_itertools.recipes, line:588 at site-packages\setuptools_vendor\more_itertools\recipes.py

生成*value*，后跟*iterator*中的元素。
        >>> value = '0'
        >>> iterator = ['1', '2', '3']
        >>> list(prepend(value, iterator))
        ['0', '1', '2', '3']
    预先考虑多个值,看到 :func:'itertools.Chain' 或 :func:'value_Chain'。

🌿91 quantify(iterable, pred=<class ‘bool’>)

quantify(iterable, pred=<class ‘bool’>), module=setuptools._vendor.more_itertools.recipes, line:172 at site-packages\setuptools_vendor\more_itertools\recipes.py

返回谓词为真的次数。
    >>> quantify([True, False, True])
    2

🌿92 random_combination_with_replacement(iterable, r)

random_combination_with_replacement(iterable, r), module=setuptools._vendor.more_itertools.recipes, line:529 at site-packages\setuptools_vendor\more_itertools\recipes.py

返回*iterable*中元素的随机*r*长度子序列，允许重复单个元素。
        >>> random_combination_with_replacement(range(3), 5) # doctest:+SKIP
        (0, 0, 1, 2, 2)
    这相当于一个随机从``itertools.combinations_with_replacement(iterable, r)``选择。

🌿93 random_combination(iterable, r)

random_combination(iterable, r), module=setuptools._vendor.more_itertools.recipes, line:513 at site-packages\setuptools_vendor\more_itertools\recipes.py

返回*iterable*中元素的随机*r*长度子序列。
        >>> random_combination(range(5), 3)  # doctest:+SKIP
        (2, 3, 4)
    这相当于从 ``itertools.combinations(iterable, r)``中取一个随机选择。

🌿94 random_permutation(iterable, r=None)

random_permutation(iterable, r=None), module=setuptools._vendor.more_itertools.recipes, line:495 at site-packages\setuptools_vendor\more_itertools\recipes.py

返回*iterable*中元素的随机*r*长度排列。
如果未指定*r*或为``None``，则*r*默认为*iterable*的长度。
        >>> random_permutation(range(5))  # doctest:+SKIP
        (3, 4, 0, 1, 2)
这相当于从 ``itertools.permutations(iterable, r)`` 中取一个随机选择。

🌿95 random_product(*args, repeat=1)

random_product(*args, repeat=1), module=setuptools._vendor.more_itertools.recipes, line:475 at site-packages\setuptools_vendor\more_itertools\recipes.py

从每个输入可迭代对象中随机绘制一个项。
        >>> random_product('abc', range(4), 'XYZ')  # doctest:+SKIP
        ('c', 3, 'Z')
如果*repeat*作为关键字参数提供，那么将从每个可迭代对象中抽取许多项。
        >>> random_product('abcd', range(4), repeat=2)  # doctest:+SKIP
        ('a', 2, 'd', 3)
这相当于从 ``itertools.product(*args, **kwarg)`` 中取一个随机选择。

🌿96 repeatfunc(func, times=None, *args)

repeatfunc(func, times=None, *args), module=setuptools._vendor.more_itertools.recipes, line:231 at site-packages\setuptools_vendor\more_itertools\recipes.py

反复调用带 *args* 的 *func*，返回结果的可迭代对象。
如果指定了*times*，迭代对象将在重复多次后终止:
        >>> from operator import add
        >>> times = 4
        >>> args = 3, 5
        >>> list(repeatfunc(add, times, *args))
        [8, 8, 8, 8]
    如果*times*为 ``None``，则可迭代对象不会终止:
        >>> from random import randrange
        >>> times = None
        >>> args = 1, 11
        >>> take(6, repeatfunc(randrange, times, *args))  # doctest:+SKIP
        [2, 4, 8, 1, 8, 4]

🌿97 roundrobin(*iterables)

roundrobin(*iterables), module=setuptools._vendor.more_itertools.recipes, line:300 at site-packages\setuptools_vendor\more_itertools\recipes.py

从每个可迭代对象中产生一个项，在它们之间交替。
        >>> list(roundrobin('ABC', 'D', 'EF'))
        ['A', 'D', 'E', 'B', 'F', 'C']
此函数产生与 :func:`interleave_longest` 相同的输出，但对于某些输入可能表现更好(特别是当可迭代对象数量较少时)。

🌿98 tabulate(function, start=0)

tabulate(function, start=0), module=setuptools._vendor.more_itertools.recipes, line:76 at site-packages\setuptools_vendor\more_itertools\recipes.py

返回 ``func(start)``, ``func(start + 1)``, ``func(start + 2)``... 的结果的迭代器。
*func*应该是一个接受一个整数参数的函数。如果未指定*start*，则默认为0。每次迭代器向前移动时，它都会被加1。
        >>> square = lambda x: x ** 2
        >>> iterator = tabulate(square, -3)
        >>> take(4, iterator)
        [9, 4, 1, 0]

🌿99 tail(n, iterable)

tail(n, iterable), module=setuptools._vendor.more_itertools.recipes, line:94 at site-packages\setuptools_vendor\more_itertools\recipes.py

返回*iterable*中最后*n*项的迭代器。
    >>> t = tail(3, 'ABCDEFG')
    >>> list(t)
    ['E', 'F', 'G']

🌿100 take(n, iterable)

take(n, iterable), module=setuptools._vendor.more_itertools.recipes, line:60 at site-packages\setuptools_vendor\more_itertools\recipes.py

以列表形式返回可迭代对象的前*n*项。
        >>> take(3, range(10))
        [0, 1, 2]
如果可迭代对象中少于*n*个元素，则返回所有元素。
        >>> take(10, range(3))
        [0, 1, 2]

🌿101 unique_everseen(iterable, key=None)

unique_everseen(iterable, key=None), module=setuptools._vendor.more_itertools.recipes, line:377 at site-packages\setuptools_vendor\more_itertools\recipes.py

产生独特的元素，保持秩序。
可使用可哈希和不可哈希项混合的序列。
        >>> list(unique_everseen('AAAABBBCCDAABBB'))
        ['A', 'B', 'C', 'D']
        >>> list(unique_everseen('ABBCcAD', str.lower))
        ['A', 'B', 'C', 'D']
对于不可哈希项，该函数将较慢(即' O(n^2) ')。
请记住，``list``对象是不可哈希的-您可以使用*key*参数将列表转换为元组(这是可哈希的)以避免减速。
        >>> iterable = ([1, 2], [2, 3], [1, 2])
        >>> list(unique_everseen(iterable))  # Slow
        [[1, 2], [2, 3]]
        >>> list(unique_everseen(iterable, key=tuple))  # Faster
        [[1, 2], [2, 3]]
类似地，您可能希望将不可哈希的``set``对象转换为``key=frozenset``。
对于``dict``对象， ``key=lambda x: frozenset(x.items())``可以使用。

🌿102 unique_justseen(iterable, key=None)

unique_justseen(iterable, key=None), module=setuptools._vendor.more_itertools.recipes, line:422 at site-packages\setuptools_vendor\more_itertools\recipes.py

按顺序生成元素，忽略串行重复项。
    >>> list(unique_justseen('AAAABBBCCDAABBB'))
    ['A', 'B', 'C', 'D', 'A', 'B']
    >>> list(unique_justseen('ABBCcAD', str.lower))
    ['A', 'B', 'C', 'A', 'D']

🔵类

🌿103 setuptools._vendor.more_itertools.more.AbortThread

AbortThread, setuptools._vendor.more_itertools.more.AbortThread, module=setuptools._vendor.more_itertools.more, line:3396 at site-packages\setuptools_vendor\more_itertools\more.py

🌿104 setuptools._vendor.more_itertools.more.bucket

bucket, setuptools._vendor.more_itertools.more.bucket, module=setuptools._vendor.more_itertools.more, line:851 at site-packages\setuptools_vendor\more_itertools\more.py

包装*iterable*并返回一个对象，该对象根据*key*函数将其可迭代对象存储为子可迭代对象。
        >>> iterable = ['a1', 'b1', 'c1', 'a2', 'b2', 'c2', 'b3']
        >>> s = bucket(iterable, key=lambda x: x[0])  # Bucket by 1st character
        >>> sorted(list(s))  # Get the keys
        ['a', 'b', 'c']
        >>> a_iterable = s['a']
        >>> next(a_iterable)
        'a1'
        >>> next(a_iterable)
        'a2'
        >>> list(s['b'])
        ['b1', 'b2', 'b3']
    原始可迭代对象将被高级化，其项将被缓存，直到它们被子可迭代对象使用。
    这可能需要大量的存储空间。默认情况下，尝试选择不属于任何项的bucket将耗尽可迭代对象并缓存所有值。
    如果您指定了一个验证器函数，那么选中的桶将根据它进行检查。
        >>> from itertools import count
        >>> it = count(1, 2)  # Infinite sequence of odd numbers
        >>> key = lambda x: x % 10  # Bucket by last digit
        >>> validator = lambda x: x in {1, 3, 5, 7, 9}  # Odd digits only
        >>> s = bucket(it, key=key, validator=validator)
        >>> 2 in s
        False
        >>> list(s[2])
        []

🌿105 setuptools._vendor.more_itertools.more.callback_iter

callback_iter, setuptools._vendor.more_itertools.more.callback_iter, module=setuptools._vendor.more_itertools.more, line:3400 at site-packages\setuptools_vendor\more_itertools\more.py

将使用回调函数的函数转换为迭代器。
    设*func*是一个带 `callback` 关键字参数的函数。
    例如:
    >>> def func(callback=None):
    ...     for i, c in [(1, 'a'), (2, 'b'), (3, 'c')]:
    ...         if callback:
    ...             callback(i, c)
    ...     return 4
    使用``with callback_iter(func)``来获取传递给回调函数的参数的迭代器。
    >>> with callback_iter(func) as it:
    ...     for args, kwargs in it:
    ...         print(args)
    (1, 'a')
    (2, 'b')
    (3, 'c')
    该函数将在后台线程中调用。``done``属性指示它是否已完成执行。
    >>> it.done
    True
    如果它成功完成，它的返回值将在result属性中可用。
    >>> it.result
    4
    注:
    *如果函数使用了除``callback``以外的关键字参数，请输入 *callback_kwd* 。
    *如果它完成了执行，但引发了一个异常，访问``result``属性将引发相同的异常。
    *如果它还没有完成执行，从with块中访问result属性会引发RuntimeError。
    *如果它还没有完成执行，从``with``块外部访问``result``属性会引发 ``more_itertools.AbortThread`` 例外。
    *提供 *wait_seconds* 来调整它轮询输出的频率。

property

1 done=<property object at 0x0000028306E0E1D8> kind:property type:property class:<class ‘setuptools._vendor.more_itertools.more.callback_iter’>
2 result=<property object at 0x0000028306E0E228> kind:property type:property class:<class ‘setuptools._vendor.more_itertools.more.callback_iter’>

🌿106 setuptools._vendor.more_itertools.more.countable

countable, setuptools._vendor.more_itertools.more.countable, module=setuptools._vendor.more_itertools.more, line:3796 at site-packages\setuptools_vendor\more_itertools\more.py

包装*iterable*并记录已经消耗了多少项。
    ``items seen``属性从``0``开始，随着可迭代对象被消耗而增加:
        >>> iterable = map(str, range(10))
        >>> it = countable(iterable)
        >>> it.items_seen
        0
        >>> next(it), next(it)
        ('0', '1')
        >>> list(it)
        ['2', '3', '4', '5', '6', '7', '8', '9']
        >>> it.items_seen
        10

🌿107 setuptools._vendor.more_itertools.more.islice_extended

islice_extended, setuptools._vendor.more_itertools.more.islice_extended, module=setuptools._vendor.more_itertools.more, line:2268 at site-packages\setuptools_vendor\more_itertools\more.py

支持*stop*、*start*和*step*的负值的 :func:`itertools.islice` 的扩展。
        >>> iterable = iter('abcdefgh')
        >>> list(islice_extended(iterable, -4, -1))
        ['e', 'f', 'g']
    带有负数的切片需要对*iterable*进行一些缓存，但是这个函数会尽量减少所需的内存量。
    例如，可以对无限迭代器使用负步骤:
        >>> from itertools import count
        >>> list(islice_extended(count(), 110, 99, -2))
        [110, 108, 106, 104, 102, 100]
    你也可以直接使用切片表法:
        >>> iterable = map(str, count())
        >>> it = islice_extended(iterable)[10:20:2]
        >>> list(it)
        ['10', '12', '14', '16', '18']

🌿108 setuptools._vendor.more_itertools.more.numeric_range

numeric_range, setuptools._vendor.more_itertools.more.numeric_range, module=setuptools._vendor.more_itertools.more, line:1889 at site-packages\setuptools_vendor\more_itertools\more.py

内置``range()``函数的扩展，其参数可以是任何可排序的数字类型。
    只有*stop*指定，*start*默认为``0``，*step*默认为' 1``。输出项将匹配*stop*的类型:
        >>> list(numeric_range(3.5))
        [0.0, 1.0, 2.0, 3.0]
    只有*start*和*stop*指定，*step*默认为``1``。输出项将匹配*start*
        >>> from decimal import Decimal
        >>> start = Decimal('2.1')
        >>> stop = Decimal('5.1')
        >>> list(numeric_range(start, stop))
        [Decimal('2.1'), Decimal('3.1'), Decimal('4.1')]
    与*start*， *stop*和*step*指定的输出项将匹配``start + step``的类型:
        >>> from fractions import Fraction
        >>> start = Fraction(1, 2)  # Start at 1/2
        >>> stop = Fraction(5, 2)  # End at 5/2
        >>> step = Fraction(1, 2)  # Count by 1/2
        >>> list(numeric_range(start, stop, step))
        [Fraction(1, 2), Fraction(1, 1), Fraction(3, 2), Fraction(2, 1)]
    如果*step*为零，将引发``ValueError``。
        >>> list(numeric_range(3, -1, -1.0))
        [3.0, 2.0, 1.0, 0.0]
    注意浮点数的限制;所得数字的代表可能令人惊讶。
    ``datetime.datetime``对象可以用于*start*和*stop*，如果*step*是一个``datetime.timedelta``对象:
        >>> import datetime
        >>> start = datetime.datetime(2019, 1, 1)
        >>> stop = datetime.datetime(2019, 1, 3)
        >>> step = datetime.timedelta(days=1)
        >>> items = iter(numeric_range(start, stop, step))
        >>> next(items)
        datetime.datetime(2019, 1, 1, 0, 0)
        >>> next(items)
        datetime.datetime(2019, 1, 2, 0, 0)

method

1 count(self, value)

kind=method class=numeric_range objtype=function line:2081 at …\lib\site-packages\setuptools_vendor\more_itertools\more.py

2 index(self, value)

kind=method class=numeric_range objtype=function line:2084 at …\lib\site-packages\setuptools_vendor\more_itertools\more.py

🌿109 setuptools._vendor.more_itertools.more.peekable

peekable, setuptools._vendor.more_itertools.more.peekable, module=setuptools._vendor.more_itertools.more, line:234 at site-packages\setuptools_vendor\more_itertools\more.py

包装迭代器，以允许对元素进行预查找和预添加。
    对结果调用 :meth:`peek` 以获取将由 :func:`next` 返回的值。这不会推进迭代器:
        >>> p = peekable(['a', 'b'])
        >>> p.peek()
        'a'
        >>> next(p)
        'a'
    传递 :meth:`peek` 一个默认值以返回该值，而不是在迭代器耗尽时引发``StopIteration``。
        >>> p = peekable([])
        >>> p.peek('hi')
        'hi'
    peekables还提供了 :meth:`prepend` 方法，该方法在可迭代对象的头部“插入”项:
        >>> p = peekable([1, 2, 3])
        >>> p.prepend(10, 11, 12)
        >>> next(p)
        10
        >>> p.peek()
        11
        >>> list(p)
        [11, 12, 1, 2, 3]
    peekables可以被索引。索引0是将由:func:`func`返回的项，索引1是在它之后的项，依此类推:给定索引之前的值将被缓存。
        >>> p = peekable(['a', 'b', 'c', 'd'])
        >>> p[0]
        'a'
        >>> p[1]
        'b'
        >>> next(p)
        'a'
    'a'支持负索引，但请注意，它们将在源迭代器中缓存其余项，这可能需要大量存储空间。要检查peekable是否已耗尽，请检查其真值:
        >>> p = peekable(['a', 'b'])
        >>> if p:  # peekable has items
        ...     list(p)
        ['a', 'b']
        >>> if not p:  # peekable is exhausted
        ...     list(p)

method

1 peek(self, default=_marker)

kind=method class=peekable objtype=function line:307 at …\lib\site-packages\setuptools_vendor\more_itertools\more.py

返回下一个将从``next()``返回的项。
如果没有剩余项，则返回' default``。
如果没有提供 ``default``，引发 ``StopIteration``。

2 prepend(self, *items)

kind=method class=peekable objtype=function line:323 at …\lib\site-packages\setuptools_vendor\more_itertools\more.py

将项目堆叠为``next()``或``self.peek()``返回的下一个项目。
    条目将按照先入先出的顺序返回:
            >>> p = peekable([1, 2, 3])
            >>> p.prepend(10, 11, 12)
            >>> next(p)
            10
            >>> list(p)
            [11, 12, 1, 2, 3]
        通过添加项，可以“复活”先前引发 ``StopIteration`` 的peekable。
            >>> p = peekable([])
            >>> next(p)
            Traceback (most recent call last):
              ...
            StopIteration
            >>> p.prepend(1)
            >>> next(p)
            1
            >>> next(p)
            Traceback (most recent call last):
              ...
            StopIteration

🌿110 setuptools._vendor.more_itertools.more.run_length

run_length, setuptools._vendor.more_itertools.more.run_length, module=setuptools._vendor.more_itertools.more, line:2703 at site-packages\setuptools_vendor\more_itertools\more.py

    :func:`run_length.encode` 用运行长度编码压缩可迭代对象。
    它生成重复项组，并计算它们重复的次数:
        >>> uncompressed = 'abbcccdddd'
        >>> list(run_length.encode(uncompressed))
        [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
    :func:`run_length.decode` 解压先前使用运行长度编码压缩的可迭代对象。它产生解压缩可迭代对象的项:
        >>> compressed = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
        >>> list(run_length.decode(compressed))
        ['a', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'd']

static method

1 decode(iterable)

kind=static method class=run_length objtype=staticmethod line:2728 at …\lib\site-packages\setuptools_vendor\more_itertools\more.py

staticmethod(function) -> method将函数转换为静态方法。

2 encode(iterable)

kind=static method class=run_length objtype=staticmethod line:2724 at …\lib\site-packages\setuptools_vendor\more_itertools\more.py

staticmethod(function) -> method将函数转换为静态方法。

🌿111 setuptools._vendor.more_itertools.more.seekable

seekable, setuptools._vendor.more_itertools.more.seekable, module=setuptools._vendor.more_itertools.more, line:2563 at site-packages\setuptools_vendor\more_itertools\more.py

包装迭代器以允许向后和向前查找。
这将逐步缓存源可迭代对象中的项，以便可以重新访问它们。
    调用:meth:'seek'，带一个索引查找到源可迭代对象中的那个位置。
    “重置”一个迭代器,寻求``0``:
        >>> from itertools import count
        >>> it = seekable((str(n) for n in count()))
        >>> next(it), next(it), next(it)
        ('0', '1', '2')
        >>> it.seek(0)
        >>> next(it), next(it), next(it)
        ('0', '1', '2')
        >>> next(it)
        '3'
    也可以向前搜索:
        >>> it = seekable((str(n) for n in range(20)))
        >>> it.seek(10)
        >>> next(it)
        '10'
        >>> it.seek(20)  # Seeking past the end of the source isn't a problem
        >>> list(it)
        []
        >>> it.seek(0)  # Resetting works even after hitting the end
        >>> next(it), next(it), next(it)
        ('0', '1', '2')
    调用 :meth:`peek` 来提前查看一项而不推进迭代器:
        >>> it = seekable('1234')
        >>> it.peek()
        '1'
        >>> list(it)
        ['1', '2', '3', '4']
        >>> it.peek(default='empty')
        'empty'
    在迭代器结束之前，调用 :func:`bool` 将返回``True``。之后它将返回``False``:
        >>> it = seekable('5678')
        >>> bool(it)
        True
        >>> list(it)
        ['5', '6', '7', '8']
        >>> bool(it)
        False
    你可以使用 :meth:`elements` 方法查看缓存的内容。
    它返回一个 :class:`SequenceView`，一个自动更新的视图:
        >>> it = seekable((str(n) for n in range(10)))
        >>> next(it), next(it), next(it)
        ('0', '1', '2')
        >>> elements = it.elements()
        >>> elements
        SequenceView(['0', '1', '2'])
        >>> next(it)
        '3'
        >>> elements
        SequenceView(['0', '1', '2', '3'])
    默认情况下，缓存会随着源可迭代对象的进展而增长，因此要小心包装非常大或无限的可迭代对象。
    提供*maxlen*来限制缓存的大小(这当然限制了您可以查找的远)。
        >>> from itertools import count
        >>> it = seekable((str(n) for n in count()), maxlen=2)
        >>> next(it), next(it), next(it), next(it)
        ('0', '1', '2', '3')
        >>> list(it.elements())
        ['2', '3']
        >>> it.seek(0)
        >>> next(it), next(it), next(it), next(it)
        ('2', '3', '4', '5')
        >>> next(it)
        '6'

method

1 elements(self)

kind=method class=seekable objtype=function line:2693 at …\lib\site-packages\setuptools_vendor\more_itertools\more.py

2 peek(self, default=_marker)

kind=method class=seekable objtype=function line:2681 at …\lib\site-packages\setuptools_vendor\more_itertools\more.py

3 seek(self, index)

kind=method class=seekable objtype=function line:2696 at …\lib\site-packages\setuptools_vendor\more_itertools\more.py

🌿112 setuptools._vendor.more_itertools.more.SequenceView

SequenceView, setuptools._vendor.more_itertools.more.SequenceView, module=setuptools._vendor.more_itertools.more, line:2518 at site-packages\setuptools_vendor\more_itertools\more.py

返回序列对象*target*的只读视图。
    :class:`SequenceView`对象类似于Python内置的"字典视图"类型。
    它们提供了序列项的动态视图，这意味着当序列更新时，视图也会更新。
        >>> seq = ['0', '1', '2']
        >>> view = SequenceView(seq)
        >>> view
        SequenceView(['0', '1', '2'])
        >>> seq.append('3')
        >>> view
        SequenceView(['0', '1', '2', '3'])
    序列视图支持索引，切片和长度查询。它们的行为就像底层序列，除了它们不允许赋值:
        >>> view[1]
        '1'
        >>> view[1:-1]
        ['1', '2']
        >>> len(view)
        4
    序列视图作为复制的替代方案很有用，因为它们不需要(太多)额外的存储空间。

🌿113 setuptools._vendor.more_itertools.more.time_limited

time_limited, setuptools._vendor.more_itertools.more.time_limited, module=setuptools._vendor.more_itertools.more, line:3072 at site-packages\setuptools_vendor\more_itertools\more.py

从*iterable*中生成项目，直到*limit_seconds*通过。
如果时间限制在所有物品被产生之前过期，``timed_out``参数将被设置为``True``。
    >>> from time import sleep
    >>> def generator():
    ...     yield 1
    ...     yield 2
    ...     sleep(0.2)
    ...     yield 3
    >>> iterable = time_limited(0.1, generator())
    >>> list(iterable)
    [1, 2]
    >>> iterable.timed_out
    True
请注意，在生成每个项目之前检查时间，如果经过的时间大于*limit_seconds*，则迭代停止。
如果你的时间限制是1秒，但是从iterable中生成第一个项目需要2秒，那么这个函数将运行2秒而不产生任何结果。

🌿114 setuptools._vendor.more_itertools.more.UnequalIterablesError

UnequalIterablesError, setuptools._vendor.more_itertools.more.UnequalIterablesError, module=setuptools._vendor.more_itertools.more, line:1482 at site-packages\setuptools_vendor\more_itertools\more.py

☘️【ast】

ast, fullname=ast, file=ast.py

ast 模块帮助Python应用程序处理Python抽象语法的树。

☘️【numbers】

numbers, fullname=numbers, file=numbers.py

抽象基类(abc)的数字，根据PEP 3141。

☘️【textwrap】

textwrap, fullname=textwrap, file=textwrap.py

文本换行和填充。

☘️【marshal】

marshal, fullname=marshal, file=

该模块包含可以以二进制格式读取和写入Python值的函数。该格式是特定于Python的，但与机器架构问题无关。

☘️【setuptools._distutils.log】

log, fullname=setuptools._distutils.log, file=setuptools_distutils\log.py

一个类似于PEP 282的简单日志机制。

🔵统计

序号	类别	数量
1	int	5
4	str	5
8	dict	1
9	module	1
10	class	1
11	function	2
13	residual	9
14	system	8
15	private	1
16	all	24

🔵常量

🌿int

1 DEBUG 1
2 INFO 2
3 WARN 3
4 ERROR 4
5 FATAL 5

🔵模块

🌿6 sys

sys, fullname=sys, file=

🔵函数

🌿7 set_threshold(level)

set_threshold(level), module=setuptools._distutils.log, line:68 at site-packages\setuptools_distutils\log.py

🌿8 set_verbosity(v)

set_verbosity(v), module=setuptools._distutils.log, line:75 at site-packages\setuptools_distutils\log.py

🔵类

🌿9 setuptools._distutils.log.Log

Log, setuptools._distutils.log.Log, module=setuptools._distutils.log, line:15 at site-packages\setuptools_distutils\log.py

method

1 debug(self, msg, *args)

kind=method class=Log objtype=function line:43 at …\lib\site-packages\setuptools_distutils\log.py

2 error(self, msg, *args)

kind=method class=Log objtype=function line:52 at …\lib\site-packages\setuptools_distutils\log.py

3 fatal(self, msg, *args)

kind=method class=Log objtype=function line:55 at …\lib\site-packages\setuptools_distutils\log.py

4 info(self, msg, *args)

kind=method class=Log objtype=function line:46 at …\lib\site-packages\setuptools_distutils\log.py

5 log(self, level, msg, *args)

kind=method class=Log objtype=function line:40 at …\lib\site-packages\setuptools_distutils\log.py

6 warn(self, msg, *args)

kind=method class=Log objtype=function line:49 at …\lib\site-packages\setuptools_distutils\log.py

🔵私有或局部

10 _global_log <setuptools._distutils.log.Log object at 0x0000028306284308>

🔵剩余

11 loader <_frozen_importlib_external.SourceFileLoader object at 0x0000028306280FC8>
12 spec ModuleSpec(name=‘setuptools._distutils.log’, loader=<_frozen_importlib_external.SourceFileLoader object at 0x0000028306280FC8>, origin=‘…\lib\site-packages\setuptools\_distutils\log.py’)
13 _global_log <setuptools._distutils.log.Log object at 0x0000028306284308>
14 log <bound method Log.log of <setuptools._distutils.log.Log object at 0x0000028306284308>>
15 debug <bound method Log.debug of <setuptools._distutils.log.Log object at 0x0000028306284308>>
16 info <bound method Log.info of <setuptools._distutils.log.Log object at 0x0000028306284308>>
17 warn <bound method Log.warn of <setuptools._distutils.log.Log object at 0x0000028306284308>>
18 error <bound method Log.error of <setuptools._distutils.log.Log object at 0x0000028306284308>>
19 fatal <bound method Log.fatal of <setuptools._distutils.log.Log object at 0x0000028306284308>>

☘️【setuptools._vendor.packaging.about】

about, fullname=setuptools.vendor.packaging.about, file=setuptools_vendor\packaging_about.py

🔵统计

序号	类别	数量
4	str	12
6	list	1
8	dict	1
13	residual	3
14	system	17
16	all	17

🔵常量

☘️【functools】

functools, fullname=functools, file=functools.py

☘️【os】

os, fullname=os, file=os.py

☘️【re】

re, fullname=re, file=re.py

☘️【setuptools._distutils】

_distutils, fullname=setuptools.distutils, file=setuptools_distutils_init.py

☘️【_distutils_hack】

_distutils_hack, fullname=_distutils_hack, file=distutils_hack_init.py

☘️【setuptools._deprecation_warning】

_deprecation_warning, fullname=setuptools._deprecation_warning, file=setuptools_deprecation_warning.py

☘️【setuptools.version】

version, fullname=setuptools.version, file=setuptools\version.py

☘️【setuptools.monkey】

monkey, fullname=setuptools.monkey, file=setuptools\monkey.py

☘️【setuptools.extension】

extension, fullname=setuptools.extension, file=setuptools\extension.py

☘️【setuptools.extern】

extern, fullname=setuptools.extern, file=setuptools\extern_init_.py

☘️【setuptools._vendor】

_vendor, fullname=setuptools.vendor, file=setuptools_vendor_init.py

☘️【setuptools.command】

command, fullname=setuptools.command, file=setuptools\command_init_.py

☘️【setuptools.windows_support】

windows_support, fullname=setuptools.windows_support, file=setuptools\windows_support.py

☘️【setuptools.config】

config, fullname=setuptools.config, file=setuptools\config.py

☘️【setuptools.dist】

dist, fullname=setuptools.dist, file=setuptools\dist.py

☘️【setuptools.py34compat】

py34compat, fullname=setuptools.py34compat, file=setuptools\py34compat.py

☘️【setuptools._imp】

_imp, fullname=setuptools._imp, file=setuptools_imp.py

☘️【setuptools.depends】

depends, fullname=setuptools.depends, file=setuptools\depends.py

☘️【setuptools.logging】

logging, fullname=setuptools.logging, file=setuptools\logging.py

☘️【setuptools.msvc】

msvc, fullname=setuptools.msvc, file=setuptools\msvc.py

☘️【sys】

sys, fullname=sys, file=

☘️【importlib】

importlib, fullname=importlib, file=importlib_init_.py

☘️【distutils.dist】

dist, fullname=distutils.dist, file=distutils\dist.py

☘️【distutils.config】

config, fullname=distutils.config, file=distutils\config.py

☘️【distutils.extension】

extension, fullname=distutils.extension, file=distutils\extension.py

☘️【distutils.command】

command, fullname=distutils.command, file=distutils\command_init_.py

☘️【platform】

platform, fullname=platform, file=platform.py

☘️【types】

types, fullname=types, file=types.py

☘️【inspect】

inspect, fullname=inspect, file=inspect.py

☘️【ctypes】

ctypes, fullname=ctypes, file=ctypes_init_.py

☘️【io】

io, fullname=io, file=io.py

☘️【warnings】

warnings, fullname=warnings, file=warnings.py

☘️【contextlib】

contextlib, fullname=contextlib, file=contextlib.py

☘️【itertools】

itertools, fullname=itertools, file=

☘️【setuptools.extern.packaging.version】

version, fullname=setuptools.extern.packaging.version, file=setuptools_vendor\packaging\version.py

☘️【dis】

dis, fullname=dis, file=dis.py

将Python字节码反汇编为助记符。

☘️【logging】

logging, fullname=logging, file=logging_init_.py

☘️【json】

json, fullname=json, file=json_init_.py

☘️【subprocess】

subprocess, fullname=subprocess, file=subprocess.py

☘️【winreg】

winreg, fullname=winreg, file=

☘️【zipfile】

zipfile, fullname=zipfile, file=zipfile.py

☘️【setuptools.extern.packaging._structures】

_structures, fullname=setuptools.extern.packaging._structures, file=setuptools_vendor\packaging_structures.py

☘️【setuptools._vendor.packaging._manylinux】

_manylinux, fullname=setuptools._vendor.packaging._manylinux, file=setuptools_vendor\packaging_manylinux.py

☘️【setuptools._vendor.packaging._musllinux】

_musllinux, fullname=setuptools._vendor.packaging._musllinux, file=setuptools_vendor\packaging_musllinux.py

☘️【setuptools.extern.packaging.tags】

tags, fullname=setuptools.extern.packaging.tags, file=setuptools_vendor\packaging\tags.py

☘️【setuptools.extern.packaging.utils】

utils, fullname=setuptools.extern.packaging.utils, file=setuptools_vendor\packaging\utils.py

☘️【setuptools.extern.packaging.specifiers】

specifiers, fullname=setuptools.extern.packaging.specifiers, file=setuptools_vendor\packaging\specifiers.py

☘️【setuptools._vendor.more_itertools.recipes】

recipes, fullname=setuptools._vendor.more_itertools.recipes, file=setuptools_vendor\more_itertools\recipes.py

☘️【setuptools._vendor.more_itertools.more】

more, fullname=setuptools._vendor.more_itertools.more, file=setuptools_vendor\more_itertools\more.py

☘️【collections】

collections, fullname=collections, file=collections_init_.py

☘️【struct】

struct, fullname=struct, file=struct.py

☘️【operator】

operator, fullname=operator, file=operator.py

☘️【sysconfig】

sysconfig, fullname=sysconfig, file=sysconfig.py

访问Python的配置信息。

☘️【abc】

abc, fullname=abc, file=abc.py

☘️【collections.abc】

abc, fullname=collections.abc, file=collections\abc.py