'''本模块实现了提供专门的容器数据类型
Python 通用内置容器 dict 的替代方案
列表、集合和元组。
* namedtuple：用于创建具有命名字段的元组子类的工厂函数
* deque：具有快速两端添加和弹出操作的类似列表的容器
* ChainMap 类似字典的单个视图，用于创建多个映射
* Counter 用于计数可哈希对象的字典子类
* OrderedDict 记录添加顺序的字典子类
* defaultdict 当调用工厂函数提供缺失值时的字典子类
* 用户字典 便于字典子类化的字典对象包装器
* 用户列表 便于列表子类化的列表对象包装器
* 用户字符串 便于字符串子类化的字符串对象包装器
'''
全部 = [
链映射,
计数器,
有序字典,
'用户字典',
'用户列表',
'用户字符串',
'defaultdict',
双端队列,
命名元组,
]
导入 _collections_abc
导入
系统 as _sys
from itertools 导入
连接 as
链
from itertools 导入
重复 as
重复
from itertools 导入
星图 as
_星图_
from 关键词
导入
是关键字 as _iskeyword
from 操作符
导入
等于 as
等于
from 操作符
导入 itemgetter as _itemgetter
from reprlib 导入
递归表示 as
_递归表示_
from _弱引用_
导入
代理 as
_代理
尝试:
from 收藏集
导入
双端队列
除了
导入错误:
通过
否则:
_collections_abc.可变序列.
注册(
双端队列)
尝试:
from 收藏集
导入
_deque 迭代器
除了
导入错误:
通过
尝试:
from 收藏集
导入 defaultdict
除了
导入错误:
通过
################################################################################
### OrderedDict
################################################################################
类 _OrderedDictKeysView(_collections_abc.KeysView):
定义
__倒序__(
我):
yield from 反转(
我.
映射)
类 _OrderedDictItemsView(_collections_abc.
项目视图):
定义
__倒序__(
我):
对于
键
进入
反转(
我.
映射):
产生 (
键,
我.
映射[
键])
类 _OrderedDictValuesView(_collections_abc.
值视图):
定义
__倒序__(
我):
对于
键
进入
反转(
我.
映射):
产生
我.
映射[
键]
类
_链接(
对象):
__slots__ = '前',
'后', 'key', '__weakref__'
类
有序字典(
字典):
'记录插入顺序的字典'
# 一个继承的字典将键映射到值。
# 继承的字典提供了 __getitem__、__len__、__contains__ 和 get 方法。
# 剩余的方法是顺序感知的。
# 所有方法的 Big-O 运行时间与常规字典相同。
# 内部的 self.__map 字典将键映射到双向链表中的链接。
循环双链表以哨兵元素开始和结束。
哨兵元素永远不会被删除（这简化了算法）。
哨兵位于 self.__hardroot 中，self.__root 中有一个弱引用代理。
prev 链接是弱引用代理（以防止循环引用）。
# 硬引用在 self.__map 中保持单个链接的活跃状态。
# 当从 OrderedDict 中删除键时，那些硬引用会消失。
定义 __new__(cls, /, *
参数, **
关键词):
创建有序字典对象并设置底层结构。
self = 字典.__new__(cls)
我.__hardroot =
_链接()
我.
__根 =
根 =
_代理(
我.__hardroot)
根.
上一个 =
根.
下一个 =
根
我.
__映射 = {}
返回 self
定义 __init__(
我,
其他=(), /, **
关键词):
初始化一个有序字典。其签名与常规字典相同
关键字参数的顺序被保留。
'''
我.
更新(
其他, **
关键词)
定义 __setitem__(
我,
键, value,
字典赋值=
字典.__setitem__,
代理=
_代理,
链接=
_链接):
'od.__setitem__(i, y) <==> od[i]=y'
# 设置新项将在链表的末尾创建一个新的链接，
# 和继承的字典一起更新了新的键/值对。
如果
键 not
进入
我:
我.__map[
键] =
链接 =
链接()
根 =
我.
__根
最后一个 =
根.
上一个
链接.
上一页,
链接.
下一,
链接.
键 =
最后,
根,
键
最后.
下一个 =
链接
根.
上一个 =
代理(
链接)
字典赋值(
我,
键, value)
定义 __delitem__(
我,
键,
删除字典项=
字典.__delitem__):
od.__delitem__(y) <==> del od[y]
删除现有项使用 self.__map 来找到链接，该链接获取
# 由更新前驱和后继节点中的链接移除。
删除字典项(
我,
键)
链接 =
我.__map.
流行(
键)
链接上一页 =
链接.
上一个
链接下一页 =
链接.
下一个
上一个链接.
下一个 =
链接下一页
链接下一页.
上一个 =
链接上一页
链接.
上一个 =
无。
链接.
下一个 =
无。
定义 __iter__(
我):
'od.__iter__() <==> iter(od)'
按顺序遍历链表。
根 =
我.
__根
当前 =
根.
下一个
当
当前
是 not
根:
产生
当前.
键
当前 =
当前.
下一个
定义
__倒序__(
我):
od.__reversed__() 等价于 reversed(od)
# 逆序遍历链表。
根 =
我.
__根
当前 =
根.
上一个
当
当前
是 not
根:
产生
当前.
键
当前 =
当前.
上一个
定义
清晰(
我):
'od.clear() -> None. 从 od 中移除所有项。'
根 =
我.
__根
根.
上一个 =
根.
下一个 =
根
我.__map.
清晰()
字典.
清晰(
我)
定义 popitem(
我,
最后=True):
从字典中移除并返回一个（键，值）对。
如果 last 为 true，则按 LIFO 顺序返回键值对，如果为 false，则按 FIFO 顺序返回。
'''
如果 not
我:
抛出
键错误(
字典为空)
根 =
我.
__根
如果
最后:
链接 =
根.
上一个
链接上一页 =
链接.
上一个
上一个链接.
下一个 =
根
根.
上一个 =
链接上一页
否则:
链接 =
根.
下一个
链接下一页 =
链接.
下一个
根.
下一个 =
链接下一页
链接下一页.
上一个 =
根
键 =
链接.
键
删除
我.__map[
键]
值 =
字典.
流行(
我,
键)
返回
键,
值
定义
移动到末尾(
我,
键,
最后=True):
将现有元素移动到末尾（如果 last 为 false，则移动到开头）。
如果元素不存在，则抛出 KeyError 异常。
'''
链接 =
我.__map[
键]
链接上一页 =
链接.
上一个
链接下一页 =
链接.
下一个
软链接 =
链接下一页.
上一个
上一个链接.
下一个 =
链接下一页
链接下一页.
上一个 =
链接上一页
根 =
我.
__根
如果
最后:
最后一个 =
根.
上一个
链接.
上一个 =
最后一个
链接.
下一个 =
根
根.
上一个 =
软链接
最后.
下一个 =
链接
否则:
第一 =
根.
下一个
链接.
上一个 =
根
链接.
下一个 =
第一
第一.
上一个 =
软链接
根.
下一个 =
链接
定义 __sizeof__(
我):
sizeof = _sys.getsizeof
n = len(我) + 1
# 包含根在内的链接数量
大小 = sizeof(
我.
字典)
# 实例字典
大小 += sizeof(
我.__map) * 2
# 内部字典和继承字典
大小 += sizeof(
我.__hardroot) * n
# 链接对象
大小 += sizeof(
我.__root) * n
代理对象
返回
大小
更新 =
__更新 = _collections_abc.
可变映射.
更新
定义
键(
我):
"D.keys() -> 返回一个类似于集合的对象，提供对 D 键的视图"
返回 _OrderedDictKeysView(
我)
定义
项目(
我):
"D.items() -> 一个类似于集合的对象，提供对 D 中元素的视图"
返回 _OrderedDictItemsView(
我)
定义
值(
我):
"D.values() -> 一个提供 D 的值的视图的对象"
返回 _OrderedDictValuesView(
我)
不等于 = _collections_abc.
可变映射.
不等于
标记 =
对象()
定义
流行(
我,
键,
默认=
__标记):
'''od.pop(k[,d]) -> v, 删除指定的键并返回相应的值
如果键不存在，则返回 d（如果提供），否则引发 KeyError
将引发异常。
'''
标记 =
我.
标记
结果 =
字典.
流行(
我,
键,
标记)
如果
结果
是 not
标记:
与__delitem__()中的相同。
链接 =
我.__map.
流行(
键)
链接上一页 =
链接.
上一个
链接下一页 =
链接.
下一个
上一个链接.
下一个 =
链接下一页
链接下一页.
上一个 =
链接上一页
链接.
上一个 =
无。
链接.
下一个 =
无。
返回
结果
如果
默认
是
标记:
抛出
键错误(
键)
返回
默认
定义 setdefault(
我,
键,
默认=
无):
'''如果键不在字典中，则插入键并赋予默认值。
如果键在字典中，则返回键的值，否则返回默认值。
'''
如果
键
进入
我:
返回
我[
键]
我[
键] =
默认
返回
默认
@_recursive_repr()
定义 __repr__(
我):
'od.__repr__() <==> repr(od)'
如果 not
我:
返回 '%s()' % (
我.
类.__name__,)
返回 '%s(%r)' % (
我.
类.__name__,
字典(
我.
项目()))
定义 __reduce__(
我):
返回序列化状态信息
状态 =
我.__getstate__()
如果
状态:
如果 isinstance(
状态,
元组):
状态,
插槽 =
状态
否则:
插槽 = {}
状态 =
状态.
复制()
插槽 =
插槽.
复制()
对于 k
进入
变量(
有序字典()):
状态.
流行(k,
无)
插槽.
流行(k,
无)
如果
插槽:
状态 =
状态,
插槽
否则:
状态 =
状态
或者
无。
返回
我.
类, (),
状态,
无,
迭代(
我.
项目())
定义
复制(
我):
'od.copy() -> od 的浅拷贝'
返回
我.
类(
我)
@classmethod
定义 fromkeys(cls,
可迭代对象, value=
无):
创建一个新有序字典，键来自可迭代对象，值设置为指定的值。
'''
self = cls()
对于
键
进入
可迭代对象:
我[
键] =
值
返回 self
定义
__等于__(
我,
其他):
'''od.__eq__(y) <==> od==y. 与另一个 OD 的比较是有序敏感的
而与常规映射的比较是无序敏感的。
'''
如果 isinstance(
其他,
有序字典):
返回
字典.
__等于__(
我,
其他)
以及
所有(
地图(
_等于,
我,
其他))
返回
字典.
__等于__(
我,
其他)
定义 __ior__(
我,
其他):
我.
更新(
其他)
返回 self
定义 __or__(
我,
其他):
如果 not isinstance(
其他,
字典):
返回 NotImplemented
新 =
我.
类(
我)
新.
更新(
其他)
返回
新
定义 __ror__(
我,
其他):
如果 not isinstance(
其他,
字典):
返回 NotImplemented
新 =
我.
类(
其他)
新.
更新(
我)
返回
新
尝试:
from 收藏集
导入 OrderedDict
除了
导入错误:
保持纯 Python 版本不变。
通过
################################################################################
命名元组
################################################################################
尝试:
from 收藏集
导入
元组获取器
除了
导入错误:
元组获取器 =
lambda 表达式
索引,
文档:
属性(_itemgetter(
索引),
文档=
文档)
定义
命名元组(
类型名,
字段名, *,
重命名=False,
默认值=
无,
模块=
无):
返回一个新的具有命名字段的元组子类。
>>> Point = namedtuple('Point', ['x', 'y'])
>>> Point.__doc__ # 类的文档字符串
'Point(x, y)'
>>> p = Point(11, y=22) # 使用位置参数或关键字实例化
>>> p[0] + p[1] # 类似普通元组的索引访问
33
>>> x, y = p # 如常规元组一样解包
>>> x, y
(11, 22)
>>> p.x + p.y # 通过名称也可以访问字段
33
>>> d = p._asdict() # 转换为字典
>>> d['x']
11
>>> Point(**d) # 从字典转换
Point(x=11, y=22)
>>> p._replace(x=100) # _replace() 类似于 str.replace()，但针对命名字段
Point(x=100, y=22)
"""
验证字段名称。根据用户的选择，或者生成错误
消息或自动将字段名称替换为有效名称。
如果 isinstance(
字段名, str):
字段名 =
字段名.
替换(
逗号,
空格).
分割()
字段名 =
列表(
地图(str,
字段名))
类型名 = _sys.
内部人员(str(
类型名))
如果
重命名:
看过 =
设置()
对于
索引,
名称
进入
列举(
字段名):
如果 (not
名称.isidentifier()
或者 _iskeyword(
名称)
或者
名称.
以...开头(
下划线)
或者
名称
进入
已见):
字段名[
索引] = f
“_”{
索引}'
已见.
添加(
名称)
对于
名称
进入 [
类型名] +
字段名:
如果
类型(
名称)
是 not str:
抛出
类型错误(
'类型名称和字段名称必须是字符串')
如果 not
名称.isidentifier():
抛出
值错误(
'类型名称和字段名称必须是有效的 '
f'标识符：'{
名称!r}')
如果 _iskeyword(
名称):
抛出
值错误(
'类型名称和字段名称不能是 '
f'关键字：'{
名称!r}')
看过 =
设置()
对于
名称
进入
字段名:
如果
名称.
以...开头(
下划线)
以及 not
重命名:
抛出
值错误(
'字段名不能以下划线开头：'
f'{名称!r}')
如果
名称
进入
已见:
抛出
值错误(f
遇到重复的字段名：{
名称!r}')
已见.
添加(
名称)
字段默认值 = {}
如果
默认
是 not
无:
默认 =
元组(
默认值)
如果 len(
默认值) > len(
字段名):
抛出
类型错误(
'默认值比字段名称多')
字段默认值 =
字典(
反转(
列表(
压缩(
反转(
字段名),
反转(
默认值)))))
方法中使用的变量和文档字符串
字段名 =
元组(
地图(_sys.
内部人员,
字段名))
字段数量 = len(
字段名)
参数列表 =
“，”.
连接(
字段名)
如果
字段数量 == 1:
参数列表 +=
，
repr_fmt = （ +
“，”.
连接(f'{
名称}=%r'
对于
名称
进入
字段名) +
）
元组新 =
元组.
__新__
_字典,
_元组, _len, _map, _zip =
字典,
元组, len,
地图, zip
创建所有要添加到类命名空间中的命名元组方法
命名空间 = {
'_tuple_new': 新元组,
'__内置函数__': {},
'__名称__': f
'namedtuple_'{
类型名}',
}
代码 = f
'lambda _cls,'{
参数列表}
_tuple_new(_cls, ({
参数列表}))'
__新__ =
评估(
代码,
命名空间)
__new__.__name__ = '__new__'
__new__.__文档__ = f
创建新实例{
类型名}({
参数列表})'
如果
默认
是 not
无:
__new__.默认 =
默认
@classmethod
定义
_创建(cls,
可迭代对象):
结果 =
新元组(cls,
可迭代对象)
如果 _len(
结果) !=
字段数量:
抛出
类型错误(f
预期{
字段数量}
参数，获取{len(
结果)}')
返回
结果
_创建.
__函数__.
__文档__ = (f
'创建一个新的'{
类型名}
对象来自序列
'可迭代')
定义
替换(
我, /, **
关键词):
结果 =
我.
_创建(_map(
关键词.
流行,
字段名,
我))
如果
关键词:
抛出
值错误(f
'遇到意外的字段名称：'{
列表(
关键词)!r}')
返回
结果
替换.
__文档__ = (f
返回一个新的{
类型名}
替换指定的 '
用新值替换字段)
定义 __repr__(
我):
返回一个格式良好的表示字符串
返回
我.
类.__name__ + repr_fmt % self
定义 _asdict(
我):
返回一个新的字典，将字段名称映射到它们的值。
返回
_字典(
_压缩包(
我.
字段,
我))
定义 __getnewargs__(
我):
返回自身作为一个普通元组。由复制和 pickle 使用。
返回
_元组(
我)
修改函数元数据以帮助进行自省和调试
对于
方法
进入 (
__new__,
_创建.
__函数__,
替换,
__repr__,
_asdict,
__getnewargs__,
):
方法.__qualname__ = f'{
类型名}.{
方法.__name__}'
构建类命名空间字典
使用 type()构建结果类
class_namespace = {
'__doc__': f'{类型名}({
参数列表}
')',
'__slots__': (),
'_fields': 字段名,
'_field_defaults': 字段默认值,
'__new__': __new__,
_make_:
_创建,
替换:
替换,
__repr__: __repr__,
_asdict: _asdict,
'__getnewargs__': __getnewargs__,
'__match_args__': 字段名,
}
对于
索引,
名称
进入
列举(
字段名):
文档 = _sys.
内部人员(f
字段编号别名{
索引}')
类命名空间[
名称] =
_元组获取器(
索引,
文档)
结果 =
类型(
类型名, (
元组,),
类命名空间)
为了使序列化工作，需要将 __module__ 变量设置为帧
在创建命名元组的位置。在环境允许的情况下跳过此步骤。
# sys._getframe 未定义（例如 Jython）或 sys._getframe 未定义
为大于 0 的参数定义（IronPython），或者用户有
指定了特定的模块。
如果
模块
是
无:
尝试:
模块 = _sys.
_获取框架模块名称(1)
或者 '__main__'
除了
属性错误:
尝试:
模块 = _sys._getframe(1).
全局变量.
获取(
'__名称__', '__main__')
除了 (
属性错误,
值错误):
通过
如果
模块
是 not
无:
结果.__module__ =
模块
返回
结果
########################################################################
### 计数器
########################################################################
定义 _count_elements(
映射,
可迭代对象):
'从可迭代对象中计数元素。'
映射获取 =
映射.
获取
对于
元素
进入
可迭代对象:
映射[
元素] =
映射获取(
元素, 0) + 1
尝试:
如果可用则加载 C 语言辅助函数
from 收藏集
导入 _count_elements
除了
导入错误:
通过
类
计数器(
字典):
'''字典子类，用于计数可哈希项。有时也称为包或多重集。元素存储为字典键及其计数
或多重集。元素存储为字典键及其计数
存储为字典值。
>>> c = Counter('abcdeabcdabcaba') # 从字符串中计数元素
>>> c.most_common(3) # 三种最常见的元素
[(a, 5), (b, 4), (c, 3)]
>>> sorted(c) # 列出所有唯一元素
['a', 'b', 'c', 'd', 'e']
>>> ''.join(sorted(c.elements())) # 列出有重复的元素
'aaaaabbbbcccdde'
>>> sum(c.values()) # 所有计数的总和
15
>>> c['a'] # 字母 'a' 的计数
5
>>> for elem in 'shazam': # 从可迭代对象更新计数
... c[elem] += 1 # 将每个元素的计数加 1
>>> c['a'] # 现在有七个 'a'
7
>>> del c['b'] # 删除所有 'b'
>>> c['b'] # 现在零个 'b'
0
>>> d = Counter('simsalabim') # 创建另一个计数器
>>> c.update(d) # 在第二个计数器中添加
>>> c['a'] # 现在有九个 'a'
9
>>> c.clear() # 清空计数器
>>> c
计数器()
注意：如果计数设置为零或减少到零，它将保持
在计数器中，直到条目被删除或计数器被清除：
>>> c = Counter('aaabbc') # 翻译为：>>> c = Counter('aaabbc')
>>> c['b'] -= 2 # 将'b'的计数减去两个
>>> c.most_common() # 'b'仍然存在，但其计数为零
[('a', 3), ('c', 1), ('b', 0)]
'''
# 参考文献：
# http://zh.wikipedia.org/wiki/多重集
# http://www.gnu.org/software/smalltalk/manual-base/html_node/包.html
# http://www.demo2s.com/Tutorial/Cpp/0380__集合-多重集/目录 0380__集合-多重集.htm
# http://code.activestate.com/recipes/259174/
# Knuth, TAOCP 第 2 卷第 4.6.3 节
定义 __init__(
我,
可迭代对象=
无, /, **
关键词):
创建一个新的空 Counter 对象。如果提供，则从输入可迭代对象中计数元素
或者，从另一个包含元素及其计数的映射中初始化计数
元素
>>> c = Counter() # 创建一个新的空计数器
>>> c = Counter('gallahad') # 从可迭代对象创建一个新的计数器
>>> c = Counter({'a': 4, 'b': 2}) # 从映射创建一个新的计数器
>>> c = Counter(a=4, b=2) # 从关键字参数创建一个新的计数器
'''
超级().__init__()
我.
更新(
可迭代对象, **
关键词)
定义
__缺失__(
我,
键):
'Counter 中不存在的元素数量为零。'
# 需要这样写，以防止 self[missing_item]引发 KeyError
返回 0
定义
总计(
我):
求计数之和
返回
总和(
我.
值())
定义
最常见(
我, n=
无):
列出最常见的 n 个元素及其计数，从最常见到最少。如果 n 为 None，则列出所有元素的计数。
如果 n 为 None，则列出所有元素的计数。
>>> Counter('abracadabra').most_common(3)
>>> Counter('abracadabra').最常见的(3)
[(a, 5), (b, 2), (r, 2)]
'''
模拟 Smalltalk 中的 Bag.sortedByCount
如果 n
是
无:
返回
排序(
我.
项目(),
键=_itemgetter(1), reverse=True)
# 懒加载导入以加快 Python 启动时间
导入 heapq
返回
堆队列.nlargest(n,
我.
项目(),
键=_itemgetter(1))
定义
元素(
我):
迭代元素，每个元素重复其计数次数。
>>> c = Counter('ABCABC')
>>> sorted(c.elements())
['A', 'A', 'B', 'B', 'C', 'C']
1836 的素因子示例：2 的平方乘以 3 的三次方乘以 17 的一次方
>>> 导入 math 模块
>>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
>>> math.prod(prime_factors.elements())
1836
注意，如果某个元素的计数被设置为 0 或为负数，
elements() 方法将忽略它。
'''
# 模拟 Smalltalk 中的 Bag.do 和 C++ 中的 Multiset.begin。
返回
_链.from_iterable(_starmap(_repeat,
我.
项目()))
需要时覆盖字典方法
@classmethod
定义 fromkeys(cls,
可迭代对象, v=
无):
对于计数器没有等效方法，因为其语义
在 Counter.fromkeys('aaabbc', v=2)这样的情况下，#会变得模糊不清。
初始化计数器为零值并不是必要的，因为零已经是计数器查找的默认值。
# 是计数器查找的默认值。初始化
对于#，使用 Counter(set(iterable))可以轻松初始化为 1。
更多复杂情况，首先创建一个字典
理解或 dict.fromkeys()
抛出
不支持的操作异常(
`Counter.fromkeys() 未定义。请使用 Counter(iterable) 代替。`)
定义
更新(
我,
可迭代对象=
无, /, **
关键词):
类似于 dict.update()，但添加计数而不是替换它们。
源可以是可迭代对象、字典或另一个 Counter 实例。
>>> c = Counter('which')
>>> c.update('witch') # 从另一个可迭代对象添加元素
>>> d = Counter('watch')
>>> c.update(d) # 从另一个 Counter 中添加元素
>>> c['h'] # 'h'在 which, witch 和 watch 中出现了四次
4
'''
# 正常的 dict.update()操作在这里没有意义，因为
替换行为导致一些原始未更改的计数
被混合到所有其他计数中，形成了一个混乱的混合体
在大多数计数上下文中没有直接的解释
因此，我们实现直接相加。输入和输出
#和输出允许包含零和负数计数。
如果
可迭代的
是 not
无:
如果 isinstance(
可迭代对象, _collections_abc.
映射):
如果
我:
自取 =
我.
获取
对于
元素,
计算
进入
可迭代对象.
项目():
我[
元素] =
计算 +
自取(
元素, 0)
否则:
# 当计数器为空时的快速路径
超级().
更新(
可迭代对象)
否则:
_count_elements(我,
可迭代对象)
如果
关键词:
我.
更新(
关键词)
定义
减法(
我,
可迭代对象=
无, /, **
关键词):
'''与 dict.update()类似，但减去计数而不是替换它们。
计数可以减少到零以下。输入和输出都是
允许包含零和负数计数。
源可以是可迭代对象、字典或另一个 Counter 实例。
>>> c = Counter('which')
>>> c.subtract('witch') # 从另一个可迭代对象中减去元素
>>> c.subtract(Counter('watch')) # 从另一个 Counter 中减去元素
>>> c['h'] # h 在 which 中的数量减去 1，在 witch 中的数量减去 1，在 watch 中的数量减去 1
0
>>> c['w'] # w 在 which 中的数量减去 1，在 witch 中的数量减去 1，在 watch 中的数量减去 1
-1
'''
如果
可迭代的
是 not
无:
自取 =
我.
获取
如果 isinstance(
可迭代对象, _collections_abc.
映射):
对于
元素,
计算
进入
可迭代对象.
项目():
我[
元素] =
自取(
元素, 0) -
计算
否则:
对于
元素
进入
可迭代对象:
我[
元素] =
自取(
元素, 0) - 1
如果
关键词:
我.
减法(
关键词)
定义
复制(
我):
返回一个浅拷贝。
返回
我.
类(
我)
定义 __reduce__(
我):
返回
我.
类, (
字典(
我),)
定义 __delitem__(
我,
元素):
类似于 dict.__delitem__()，但不会因为缺少值而引发 KeyError。
如果
元素
进入
我:
超级().__delitem__(
元素)
定义 __repr__(
我):
如果 not
我:
返回 f'{
我.
类.__name__}()'
尝试:
# dict() 保留由 most_common() 返回的顺序
d = 字典(
我.
最常见())
除了
类型错误:
# 处理值不可排序的情况
d = 字典(
我)
返回 f'{
我.
类.__name__}({d!r})'
# 在以下文献中讨论了类似集合的数学运算：
# Knuth TAOCP 第二卷 4.6.3 练习 19
# 以及在 http://en.wikipedia.org/wiki/Multiset
#
输出保证只包含正数计数。
#
# 要去除负数和零计数，请添加一个空计数器：
# c += Counter()
#
结果按元素首次出现的时间排序
左操作数中遇到，然后按顺序
在右操作数中遇到。
#
当多重性都为零或一时，多重集操作
# 保证与相应的操作等价
# 对于常规集合。
给定计数多重集，例如：
cp = Counter(a=1, b=0, c=1)
cq = Counter(c=1, d=0, e=1)
对应的正则集将是：
# sp = {'a', 'c'}
# sq = {'c', 'e'}
所有以下关系都成立：
集合(cp + cq) 等于 sp | sq
# 集合(cp - cq) 等于 sp - sq
# 集合(cp | cq) 等于 sp | sq
# 集合(cp & cq) 等于 sp & sq
# (cp == cq) 等于 (sp == sq)
(cp ≠ cq) 等价于 (sp ≠ sq)
(cp ≤ cq) 等价于 (sp ≤ sq)
(cp < cq) 等价于 (sp < sq)
(cp ≥ cq) 等价于 (sp ≥ sq)
# (cp > cq) == (sp > sq)
定义
__等于__(
我,
其他):
如果所有计数都一致则为真。缺失的计数被视为零。
如果 not isinstance(
其他,
计数器):
返回 NotImplemented
返回
所有(
我[e] ==
其他[e]
对于 c
进入 (
我,
其他)
对于 e
进入 c)
定义 __ne__(
我,
其他):
'若有任何计数不一致。缺失的计数视为零。'
如果 not isinstance(
其他,
计数器):
返回 NotImplemented
返回 not self ==
其他
定义 __le__(
我,
其他):
'如果 self 中的所有计数都是 other 中的子集，则为真。'
如果 not isinstance(
其他,
计数器):
返回 NotImplemented
返回
所有(
我[e] <=
其他[e]
对于 c
进入 (
我,
其他)
对于 e
进入 c)
定义 __lt__(
我,
其他):
如果 self 中的所有计数都是 other 中的适当子集。
如果 not isinstance(
其他,
计数器):
返回 NotImplemented
返回 self <=
其他
以及 self !=
其他
定义 __ge__(
我,
其他):
'如果 self 中的所有计数都是 other 中的超集，则为 True。'
如果 not isinstance(other,
计数器):
返回 NotImplemented
返回
所有(
我[e]
≥
其他[e]
对于 c
进入 (
我,
其他)
对于 e
进入 c)
定义 __gt__(
我,
其他):
如果 self 中的所有计数都是 other 中的正确超集。
如果 not isinstance(
其他,
计数器):
返回 NotImplemented
返回 self
≥
其他
以及 self !=
其他
定义 __add__(
我,
其他):
将两个计数器的计数相加。
>>> Counter('abbb') + Counter('bcc')
计数器({'b': 4, 'c': 2, 'a': 1})
'''
如果 not isinstance(
其他,
计数器):
返回 NotImplemented
结果 =
计数器()
对于
元素,
计算
进入
我.
项目():
新计数 =
计算 +
其他[
元素]
如果
新计数 > 0:
结果[
元素] =
新计数
对于
元素,
计算
进入
其他.
项目():
如果
元素 not
进入 self
以及
计算 > 0:
结果[
元素] =
计算
返回
结果
定义 __sub__(
我,
其他):
减去计数，但只保留计数为正的结果。
>>> Counter('abbbc') - Counter('bccd')
Counter({'b': 2, 'a': 1})
'''
如果 not isinstance(
其他,
计数器):
返回 NotImplemented
结果 =
计数器()
对于
元素,
计算
进入
我.
项目():
新计数 =
计算 - other[
元素]
如果
新计数 > 0:
结果[
元素] =
新计数
对于
元素,
计算
进入 other.
项目():
如果
元素 not
进入 self
以及
计算 < 0:
结果[
元素] = 0 -
计算
返回
结果
定义 __or__(
我, other):
合并是两个输入计数器中值最大的一个。
>>> Counter('abbb') | Counter('bcc')
Counter({'b': 3, 'c': 2, 'a': 1})
'''
如果 not isinstance(other,
计数器):
返回 NotImplemented
结果 =
计数器()
对于
元素,
计算
进入
我.
项目():
其他数量 = other[
元素]
新计数 =
其他数量
如果
计算 <
其他数量
否则
计算
如果
新计数 > 0:
结果[
元素] =
新计数
对于
元素,
计算
进入 other.
项目():
如果
元素 not
进入 self
以及
计算 > 0:
结果[
元素] =
计算
返回
结果
定义 __and__(
我, other):
交集是相应计数的最小值。
>>> Counter('abbb') & Counter('bcc')
Counter({'b': 1})
'''
如果 not isinstance(other,
计数器):
返回 NotImplemented
结果 =
计数器()
对于
元素,
计算
进入
我.
项目():
其他数量 = other[
元素]
新计数 =
计算
如果
计算 <
其他数量
否则
其他数量
如果
新计数 > 0:
结果[
元素] =
新计数
返回
结果
定义 __pos__(
我):
'添加一个空计数器，实际上移除了负数和零的计数'
结果 =
计数器()
对于
元素,
计算
进入
我.
项目():
如果
计算 > 0:
结果[
元素] =
计算
返回
结果
定义 __neg__(
我):
'从空计数器中减去。移除正数和零的计数，'
并且翻转负数的符号。
'''
结果 =
计数器()
对于
元素,
计算
进入
我.
项目():
如果
计算 < 0:
结果[
元素] = 0 -
计算
返回
结果
定义
保持积极(
我):
'''内部方法用于去除计数为负数或零的元素'''
非正数 = [
元素
对于
元素,
计算
进入
我.
项目()
如果 not
计算 > 0]
对于
元素
进入
非正数:
删除
我[
元素]
返回 self
定义 __iadd__(
我, other):
从另一个计数器中就地添加，仅保留正数计数。
>>> c = Counter('abbb')
>>> c += Counter('bcc')
>>> c
计数器({'b': 4, 'c': 2, 'a': 1})
'''
对于
元素,
计算
进入 other.
项目():
我[
元素] +=
计算
返回
我.
保持积极()
定义 __isub__(
我,
其他):
内置减法计数器，但仅保留正数结果。
>>> c = Counter('abbbc')
>>> c -= Counter('bccd')
>>> c
Counter({'b': 2, 'a': 1})
'''
对于
元素,
计算
进入
其他.
项目():
我[
元素] -=
计算
返回
我.
保持积极()
定义 __ior__(
我, other):
'原地并集是两个计数器中值的最大值。'
>>> c = Counter('abbb')
'>>> c |= Counter(''bcc'')'
>>> c
Counter({'b': 3, 'c': 2, 'a': 1})
'''
对于
元素,
其他数量
进入 other.
项目():
计算 =
我[
元素]
如果
其他数量 >
数量:
我[
元素] =
其他数量
返回
我.
保持积极()
定义 __iand__(
我, other):
内置交集是最小对应计数。
>>> c = Counter('abbb')
>>> c &= Counter('bcc')
>>> c
Counter({'b': 1})
'''
对于
元素,
计算
进入
我.
项目():
其他数量 = other[
元素]
如果
其他数量 <
数量:
我[
元素] =
其他数量
返回
我.
保持积极()
########################################################################
### 链映射
########################################################################
类
链映射(_collections_abc.
可变映射):
''' 链映射将多个字典（或其他映射）组合在一起
创建一个单一的可更新视图。
底层映射存储在一个列表中。该列表是公开的，可以
可以使用 *maps* 属性进行访问或更新。没有其他
状态
查找会依次搜索底层映射，直到找到键为止。
相比之下，写入、更新和删除操作仅对第一个映射进行。
映射进行。
'''
定义 __init__(
我, *maps):
初始化一个 ChainMap，将 *maps* 设置为给定的映射。
如果没有提供映射，则使用一个空的字典。
'''
我.
映射 =
列表(maps)
或者 [{}]
总是至少一个映射
定义
__缺失__(
我,
键):
抛出
键错误(
键)
定义 __getitem__(
我,
键):
对于
映射
进入
我.maps:
尝试:
返回
映射[
键]
不能在 defaultdict 中使用 'key in 映射'
除了
键错误:
通过
返回
我.
__缺失__(
键)
支持定义 __missing__ 的子类
定义
获取(
我,
键,
默认=
无):
返回
我[
键]
如果
键
进入 self
否则
默认
定义 __len__(
我):
返回 len(
设置().
并集(*
我.maps))
尽可能重用存储的哈希值
定义 __iter__(
我):
d = {}
对于
映射
进入
地图(
字典.fromkeys,
反转(
我.maps)):
d |= 映射
尽可能重用存储的哈希值
返回
迭代(d)
定义
包含(
我,
键):
返回
任何(
键
进入 m
对于 m
进入
我.maps)
定义 __bool__(
我):
返回
任何(
我.maps)
@_recursive_repr()
定义 __repr__(
我):
返回 f'{
我.
类.__name__}({
“，”.
连接(
地图(
表示,
我.maps))})'
@classmethod
定义 fromkeys(cls,
可迭代对象, *
参数):
'使用可迭代对象创建一个 ChainMap。'
返回 cls(
字典.fromkeys(
可迭代对象, *
参数))
定义
复制(
我):
'创建一个新的 ChainMap 或子类，包含 maps[0]的新副本和 maps[1:]的引用。'
返回
我.
类(
我.maps[0].
复制(), *
我.maps[1
])
__复制__ =
复制
定义
新子(
我, m=
无, **
关键字参数):
Django 的 Context.push()类似
新的 ChainMap，后面跟着所有之前的映射。
如果没有提供映射，则使用空字典。
关键字参数更新映射或新的空字典。
'''
如果 m
是
无:
m = kwargs
elif 关键字参数:
m.更新(
关键字参数)
返回
我.
类(m, *
我.maps)
@property
定义 parents(
我):
Django 的 Context.pop()类似
从 maps[1:]创建新的 ChainMap
返回
我.
类(*
我.maps[1
])
定义 __setitem__(
我,
键, value):
我.maps[0
]
[键] =
值
定义 __delitem__(
我,
键):
尝试:
删除
我.maps[0
]
[键]
除了
键错误:
抛出
键错误(f
'在第一个映射中找不到键：'{
键!r}')
定义 popitem(
我):
'从 maps[0]中移除并返回一个元素对。如果 maps[0]为空，则抛出 KeyError。'
尝试:
返回
我.maps[0].popitem()
除了
键错误:
抛出
键错误(
在第一个映射中未找到键。)
定义
流行(
我,
键, *
参数):
从 maps[0]中移除*key*并返回其值。如果*key*不在 maps[0]中，则引发 KeyError。
尝试:
返回
我.maps[0].
流行(
键, *
参数)
除了
键错误:
抛出
键错误(f
'在第一个映射中找不到键：'{
键!r}')
定义
清晰(
我):
清除 maps[0]，保留 maps[1:]。
我.maps[0].
清晰()
定义 __ior__(
我, other):
我.maps[0].
更新(other)
返回 self
定义 __or__(
我, other):
如果 not isinstance(other, _collections_abc.
映射):
返回 NotImplemented
m = 我.
复制()
m.maps[0].更新(other)
返回 m
定义 __ror__(
我, other):
如果 not isinstance(other, _collections_abc.
映射):
返回 NotImplemented
m = 字典(other)
对于
儿童
进入
反转(
我.maps):
m.更新(
儿童)
返回
我.
类(m)
################################################################################
### 用户字典
################################################################################
类
用户字典(_collections_abc.
可变映射):
# 从实现抽象方法开始
定义 __init__(
我,
字典=
无, /, **
关键字参数):
我.
数据 = {}
如果
字典
是 not
无:
我.
更新(
字典)
如果
关键字参数:
我.
更新(
关键字参数)
定义 __len__(
我):
返回 len(
我.
数据)
定义 __getitem__(
我,
键):
如果
键
进入 self.
数据:
返回
我.
数据[
键]
如果
有属性(
我.
类,
"__缺失__"):
返回
我.
类.
__缺失__(
我,
键)
抛出
键错误(
键)
定义 __setitem__(
我,
键,
项目):
我.
数据[
键] =
项目
定义 __delitem__(
我,
键):
删除
我.
数据[
键]
定义 __iter__(
我):
返回
迭代(
我.
数据)
修改 __contains__ 和 get() 以使其像字典一样工作
当存在 __missing__ 时会做什么。
定义
包含(
我,
键):
返回
键
进入
我.
数据
定义
获取(
我,
键,
默认=
无):
如果
键
进入
我:
返回
我[
键]
返回
默认
# 现在将不在 MutableMapping 中的方法添加到字典中
定义 __repr__(
我):
返回
表示(
我.
数据)
定义 __or__(
我, other):
如果 isinstance(other,
用户字典):
返回
我.
类(
我.
数据 | other.
数据)
如果 isinstance(other,
字典):
返回
我.
类(
我.
数据 | other)
返回 NotImplemented
定义 __ror__(
我, other):
如果 isinstance(other,
用户字典):
返回
我.
类(other.
数据 |
我.
数据)
如果 isinstance(other,
字典):
返回
我.
类(
其他 |
我.
数据)
返回 NotImplemented
定义 __ior__(
我, other):
如果 isinstance(other,
用户字典):
我.
数据 |= other.
数据
否则:
我.
数据 |=
其他
返回 self
定义
复制(
我):
实例 =
我.
类.__new__(
我.
类)
实例.
字典.
更新(
我.
字典)
创建副本并避免触发描述符
实例.
字典[
数据] =
我.
字典[
数据].
复制()
返回
实例
定义
复制(
我):
如果
我.
类
是
用户字典:
返回
用户字典(
我.
数据.
复制())
导入
复制
数据 =
我.
数据
尝试:
我.
数据 = {}
c = 复制.
复制(
我)
最后:
我.
数据 =
数据
c.更新(
我)
返回 c
@classmethod
定义 fromkeys(cls,
可迭代对象, value=
无):
d = cls()
对于
键
进入
可迭代对象:
d[键] =
值
返回 d
################################################################################
### 用户列表
################################################################################
类
用户列表(_collections_abc.
可变序列):
```A 大约完整的用户定义的列表对象包装器。```
定义 __init__(
我,
初始化列表=
无):
我.
数据 =
输入文本为空，请提供需要翻译的文本
如果
初始化列表
是 not
无:
# XXX 应该接受任意序列吗？
如果
类型(
初始化列表) ==
类型(
我.
数据):
我.
数据
[] =
初始化列表
elif isinstance(初始化列表,
用户列表):
我.
数据
[] =
初始化列表.
数据
[]
否则:
我.
数据 =
列表(
初始化列表)
定义 __repr__(
我):
返回
表示(
我.
数据)
定义 __lt__(
我, other):
返回
我.
数据 <
我.__cast(other)
定义 __le__(
我, other):
返回
我.
数据 <=
我.__cast(other)
定义
__等于__(
我, other):
返回
我.
数据 ==
我.__cast(other)
定义 __gt__(
我, other):
返回
我.
数据 >
我.__cast(other)
定义 __ge__(
我, other):
返回
我.
数据
≥
我.__cast(other)
定义 __cast(
我, other):
返回 other.
数据
如果 isinstance(other,
用户列表)
否则
其他
定义
包含(
我,
项目):
返回
项目
进入
我.
数据
定义 __len__(
我):
返回 len(
我.
数据)
定义 __getitem__(
我, i):
如果 isinstance(i,
切片):
返回
我.
类(
我.
数据[i])
否则:
返回
我.
数据[i]
定义 __setitem__(
我, i,
项目):
我.
数据[i] =
项目
定义 __delitem__(
我, i):
删除
我.
数据[i]
定义 __add__(
我, other):
如果 isinstance(other,
用户列表):
返回
我.
类(
我.
数据 + other.
数据)
elif isinstance(other, 类型(
我.
数据)):
返回
我.
类(
我.
数据 + other)
返回
我.
类(
我.
数据 +
列表(other))
定义 __radd__(
我, other):
如果 isinstance(other,
用户列表):
返回
我.
类(other.
数据 +
我.
数据)
elif isinstance(other, 类型(
我.
数据)):
返回
我.
类(
其他 +
我.
数据)
返回
我.
类(
列表(other) +
我.
数据)
定义 __iadd__(
我, other):
如果 isinstance(other,
用户列表):
我.
数据 += other.
数据
elif isinstance(other, 类型(
我.
数据)):
我.
数据 +=
其他
否则:
我.
数据 +=
列表(other)
返回 self
定义 __mul__(
我, n):
返回
我.
类(
我.
数据 * n)
__rmul__ = __mul__
定义 __imul__(
我, n):
我.
数据 *= n
返回 self
定义
复制(
我):
实例 =
我.
类.__new__(
我.
类)
实例.
字典.
更新(
我.
字典)
创建副本并避免触发描述符
实例.
字典[
数据] =
我.
字典[
数据
]
[
返回
实例
定义
添加(
我,
项目):
我.
数据.
添加(
项目)
定义
插入(
我, i,
项目):
我.
数据.
插入(i,
项目)
定义
流行(
我, i=-1):
返回
我.
数据.
流行(i)
定义
删除(
我,
项目):
我.
数据.
删除(
项目)
定义
清晰(
我):
我.
数据.
清晰()
定义
复制(self):
返回 self.
类(self)
定义
数量(self,
项目):
返回 self.
数据.
数量(
项目)
定义
索引(
我,
项目, *
参数):
返回
我.
数据.
索引(
项目, *
参数)
定义 reverse(
我):
我.
数据.reverse()
定义
排序(
我, /, *
参数, **
关键词):
我.
数据.
排序(*
参数, **
关键词)
定义
扩展(
我, other):
如果 isinstance(other,
用户列表):
我.
数据.
扩展(other.
数据)
否则:
我.
数据.
扩展(other)
################################################################################
### 用户字符串
################################################################################
类
用户字符串(_collections_abc.
序列):
定义 __init__(
我,
序列):
如果 isinstance(
序列, str):
我.
数据 =
序列
elif isinstance(序列,
用户字符串):
我.
数据 =
序列.
数据
[]
否则:
我.
数据 = str(
序列)
定义 __str__(
我):
返回 str(
我.
数据)
定义 __repr__(self):
返回
表示(self.
数据)
定义 __int__(self):
返回 int(self.
数据)
定义
浮点(self):
返回 float(self.
数据)
定义
复杂的(self):
返回
复杂(self.
数据)
定义
__哈希__(self):
返回
哈希(self.
数据)
定义 __getnewargs__(self):
返回 (self.
数据[:],)
定义
__等于__(self,
字符串):
如果 isinstance(
字符串,
用户字符串):
返回 self.
数据 ==
字符串.
数据
返回 self.
数据 ==
字符串
定义 __lt__(self,
字符串):
如果 isinstance(
字符串,
用户字符串):
返回 self.
数据 <
字符串.
数据
返回 self.
数据 <
字符串
定义 __le__(self,
字符串):
如果 isinstance(
字符串,
用户字符串):
返回 self.
数据 <=
字符串.
数据
返回 self.
数据 <=
字符串
定义 __gt__(self,
字符串):
如果 isinstance(
字符串,
用户字符串):
返回 self.
数据 >
字符串.
数据
返回 self.
数据 >
字符串
定义 __ge__(self,
字符串):
如果 isinstance(
字符串,
用户字符串):
返回 self.
数据
≥
字符串.
数据
返回 self.
数据
≥
字符串
定义
包含(self,
字符):
如果 isinstance(
字符,
用户字符串):
字符 =
字符.
数据
返回
字符
进入 self.
数据
定义 __len__(self):
返回 len(self.
数据)
定义 __getitem__(self,
索引):
返回 self.
类(self.
数据[
索引])
定义 __add__(self, other):
如果 isinstance(other,
用户字符串):
返回 self.
类(self.
数据 + other.
数据)
elif isinstance(other, str):
返回 self.
类(self.
数据 + other)
返回 self.
类(self.
数据 + str(other))
定义 __radd__(self, other):
如果 isinstance(other, str):
返回 self.
类(
其他 + self.
数据)
返回 self.
类(str(other) + self.
数据)
定义 __mul__(self, n):
返回 self.
类(self.
数据 * n)
__rmul__ = __mul__
定义 __mod__(self,
参数):
返回 self.
类(self.
数据 %
参数)
定义 __rmod__(self,
模板):
返回 self.
类(str(
模板) % self)
以下方法按字母顺序定义：
定义
大写(self):
返回 self.
类(self.
数据.
大写())
定义 casefold(self):
返回 self.
类(self.
数据.casefold())
定义
中心(self,
宽度, *
参数):
返回 self.
类(self.
数据.
中心(
宽度, *
参数))
定义
数量(self,
子,
开始=0,
结束=_sys.
最大尺寸):
如果 isinstance(
子,
用户字符串):
子 =
子.
数据
返回 self.
数据.
数量(
子,
开始,
结束)
定义
去前缀(self,
前缀, /):
如果 isinstance(
前缀,
用户字符串):
前缀 =
前缀.
数据
返回 self.
类(self.
数据.
去前缀(
前缀))
定义
移除后缀(self,
后缀, /):
如果 isinstance(
后缀,
用户字符串):
后缀 =
后缀.
数据
返回 self.
类(self.
数据.
移除后缀(
后缀))
定义
编码(self,
编码=
utf-8,
错误=
严格):
编码 =
UTF-8
如果
编码
是
无
否则
编码
错误 =
严格
如果
错误
是
无
否则
错误
返回 self.
数据.
编码(
编码,
错误)
定义
以...结尾(self,
后缀,
开始=0,
结束=_sys.
最大尺寸):
返回 self.
数据.
以...结尾(
后缀,
开始,
结束)
定义
展开标签页(self,
标签大小=8):
返回 self.
类(self.
数据.
展开标签页(
标签大小))
定义
找到(self,
子,
开始=0,
结束=_sys.
最大尺寸):
如果 isinstance(
子,
用户字符串):
子 =
子.
数据
返回 self.
数据.
找到(
子,
开始,
结束)
定义
格式(self, /, *
参数, **
关键词):
返回 self.
数据.
格式(*
参数, **
关键词)
定义
格式映射(self,
映射):
返回 self.
数据.
格式映射(
映射)
定义
索引(self,
子,
开始=0,
结束=_sys.
最大尺寸):
返回 self.
数据.
索引(
子,
开始,
结束)
定义 isalpha(self):
返回 self.
数据.isalpha()
定义 isalnum(self):
返回 self.
数据.isalnum()
定义 isascii(self):
返回 self.
数据.isascii()
定义 isdecimal(self):
返回 self.
数据.isdecimal()
定义 isdigit(self):
返回 self.
数据.isdigit()
定义 isidentifier(self):
返回 self.
数据.isidentifier()
定义 islower(self):
返回 self.
数据.islower()
定义 isnumeric(self):
返回 self.
数据.isnumeric()
定义 isprintable(self):
返回 self.
数据.isprintable()
定义 isspace(self):
返回 self.
数据.isspace()
定义 istitle(self):
返回 self.
数据.istitle()
定义 isupper(self):
返回 self.
数据.isupper()
定义
连接(self,
序列):
返回 self.
数据.
连接(
序列)
定义
居左(self,
宽度, *
参数):
返回 self.
类(self.
数据.
居左(
宽度, *
参数))
定义
小写(self):
返回 self.
类(self.
数据.
小写())
定义
去除字符串左侧空白字符(self,
字符=
无):
返回 self.
类(self.
数据.
去除字符串左侧空白字符(
字符))
maketrans = str.maketrans
定义 partition(self,
分隔符):
返回 self.
数据.partition(
分隔符)
定义
替换(self,
旧的,
新,
最大分割数=-1):
如果 isinstance(
旧的,
用户字符串):
旧 =
旧的.
数据
如果 isinstance(
新,
用户字符串):
新 =
新.
数据
返回 self.
类(self.
数据.
替换(
旧的,
新,
最大分割数))
定义
向后查找(self,
子,
开始=0,
结束=_sys.
最大尺寸):
如果 isinstance(
子,
用户字符串):
子 =
子.
数据
返回 self.
数据.
向后查找(
子,
开始,
结束)
定义
反向索引(self,
子,
开始=0,
结束=_sys.
最大尺寸):
返回 self.
数据.
反向索引(
子,
开始,
结束)
定义
居右(self,
宽度, *
参数):
返回 self.
类(self.
数据.
居右(
宽度, *
参数))
定义
分割(self,
分隔符):
返回 self.
数据.
分割(
分隔符)
定义
去除字符串右侧空白字符(self,
字符=
无):
返回 self.
类(self.
数据.
去除字符串右侧空白字符(
字符))
定义
分割(self,
分隔符=
无,
最大分割数=-1):
返回 self.
数据.
分割(
分隔符,
最大分割数)
定义
右分割(self,
分隔符=
无,
最大分割数=-1):
返回 self.
数据.
右分割(
分隔符,
最大分割数)
定义
按行分割(self,
保留结束符=False):
返回 self.
数据.
按行分割(
保留结束符)
定义
以...开头(self,
前缀,
开始=0,
结束=_sys.
最大尺寸):
返回 self.
数据.
以...开头(
前缀,
开始,
结束)
定义 strip(self,
字符=
无):
返回 self.
类(self.
数据.strip(
字符))
定义 swapcase(self):
返回 self.
类(self.
数据.swapcase())
定义
标题(self):
返回 self.
类(self.
数据.
标题())
定义
翻译(self, *
参数):
返回 self.
类(self.
数据.
翻译(*
参数))
定义
上(self):
返回 self.
类(self.
数据.
上())
定义
填充(self,
宽度):
返回 self.
类(self.
数据.
填充(
宽度))
