数据结构的扩展库——collections

Apache Commons Collections 4.4:Java集合处理的高级扩展库 Java的Map接口是广泛使用的集合之一,它存储键值对,并且不允许重复的键。随着编程实践的发展,用户对于Map的需求也变得越来越复杂,这推动了Map接口的扩展和新特性的引入。最新版本的Java集合框架对Map接口进行了扩展,添加了一些新的方法和功能,以满足现代编程实践中的复杂需求。举个例子,新的Map接口扩展中引入了computemerge和forEach等方法,它们提供了更灵活的方式来操作键值对。这些方法允许在单个调用中进行计算,并直接修改Map的内容,这比传统的迭代方法更为高效和简洁。 阅读详情

这个模块实现了特定目标的容器,以提供Python标准内建容器 dict , list , set , 和 tuple 的替代选择。

方法名说明
namedtuple()提供了一种类似字典的命名元组结构
deque类似列表(list)的容器,实现了在两端快速添加(append)和弹出(pop)
ChainMap可用于多字典查找键值或是设置查找优先级
Counter字典的子类,提供了可哈希对象的计数功能
OrderedDict有序字典,python3.7后由于dict已实现有序,故此类已用处不大
defaultdict字典的子类,可以为字典的键设置默认值

ChainMap

一个 ChainMap 类是为了将多个映射快速的链接到一起,这样它们就可以作为一个单元处理。它通常比创建一个新字典和多次调用 update() 要快很多。
这个类可以用于模拟嵌套作用域,并且在模版化的时候比较有用。
此方法可用于从多个可映射对象中查找某个键值对的时候使用,需要注意的是,对于同名的键,返回先出现的键值对。

class collections.ChainMap(*maps)
  • maps: 一个可以更新的映射列表。这个列表是按照第一次搜索到最后一次搜索的顺序组织的。它是仅有的存储状态,可以被修改。列表最少包含一个映射。

  • new_child(m=None): d.new_child() 调用等价于 ChainMap({}, *d.maps) 。这个方法用于创建子上下文,不改变任何父映射的值。

  • parents: d.parents 的引用等价于 ChainMap(*d.maps[1:]) 。

>>> baseline = {'music': 'bach', 'art': 'rembrandt'}
>>> adjustments = {'art': 'van gogh', 'opera': 'carmen'}
>>> list(ChainMap(adjustments, baseline))
['music', 'art', 'opera']

# 等价于
>>> combined = baseline.copy()
>>> combined.update(adjustments)
>>> list(combined)
['music', 'art', 'opera']
ChainMap的扩展用例
  • 模拟Python内部lookup链的例子
import builtins
pylookup = ChainMap(locals(), globals(), vars(builtins))
  • 让用户指定的命令行参数优先于环境变量,优先于默认值的例子
import os, argparse

defaults = {'color': 'red', 'user': 'guest'}

parser = argparse.ArgumentParser()
parser.add_argument('-u', '--user')
parser.add_argument('-c', '--color')
namespace = parser.parse_args()
command_line_args = {k: v for k, v in vars(namespace).items() if v is not None}

combined = ChainMap(command_line_args, os.environ, defaults)
print(combined['color'])
print(combined['user'])
  • 用 ChainMap 类模拟嵌套上下文的例子
c = ChainMap()        # Create root context
d = c.new_child()     # Create nested child context
e = c.new_child()     # Child of c, independent from d
e.maps[0]             # Current context dictionary -- like Python's locals()
e.maps[-1]            # Root context -- like Python's globals()
e.parents             # Enclosing context chain -- like Python's nonlocals

d['x'] = 1            # Set value in current context
d['x']                # Get first key in the chain of contexts
del d['x']            # Delete from current context
list(d)               # All nested values
k in d                # Check all nested values
len(d)                # Number of nested values
d.items()             # All nested items
dict(d)               # Flatten into a regular dictionary
  • ChainMap 类只更新链中的第一个映射,但lookup会搜索整个链。 然而,如果需要深度写和删除,也可以很容易的通过定义一个子类来实现它
class DeepChainMap(ChainMap):
    'Variant of ChainMap that allows direct updates to inner scopes'

    def __setitem__(self, key, value):
        for mapping in self.maps:
            if key in mapping:
                mapping[key] = value
                return
        self.maps[0][key] = value

    def __delitem__(self, key):
        for mapping in self.maps:
            if key in mapping:
                del mapping[key]
                return
        raise KeyError(key)

>>> d = DeepChainMap({'zebra': 'black'}, {'elephant': 'blue'}, {'lion': 'yellow'})
>>> d['lion'] = 'orange'         # update an existing key two levels down
>>> d['snake'] = 'red'           # new keys get added to the topmost dict
>>> del d['elephant']            # remove an existing key one level down
>>> d                            # display result
DeepChainMap({'zebra': 'black', 'snake': 'red'}, {}, {'lion': 'orange'})

Counter

一个计数器工具提供快速和方便的计数。比如

>>> # Tally occurrences of words in a list
>>> cnt = Counter()
>>> for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:
...     cnt[word] += 1
>>> cnt
Counter({'blue': 3, 'red': 2, 'green': 1})
>>> # Find the ten most common words in Hamlet
>>> import re
>>> words = re.findall(r'\w+', open('hamlet.txt').read().lower())
>>> Counter(words).most_common(10)
[('the', 1143), ('and', 966), ('to', 762), ('of', 669), ('i', 631),
('you', 554),  ('a', 546), ('my', 514), ('hamlet', 471), ('in', 451)]
class collections.Counter([iterable-or-mapping])

Counter 是dict 的子类,用于计数可哈希对象。它把元素作为键,把计数存储为值。计数可以是任何整数值,包括0和负数。 Counter 类有点像其他语言中的 bags或multisets。

Counter初始化:

>>> c = Counter()                           # a new, empty counter
>>> c = Counter('gallahad')                 # a new counter from an iterable
>>> c = Counter({'red': 4, 'blue': 2})      # a new counter from a mapping
>>> c = Counter(cats=4, dogs=8)             # a new counter from keyword args

Counter对象可以像dict一样调用,如果引用的键不存在,就返回一个0,而不是弹出一个 KeyError :

>>> c = Counter(['eggs', 'ham'])
>>> c['bacon']                              # count of a missing element is zero
0

把一个元素的值设为0不会从计数器中移去这个元素。要使用 del 来删除它:

>>> c['sausage'] = 0                        # counter entry with a zero count
>>> del c['sausage']                        # del actually removes the entry

计数器对象除了字典方法以外,还提供了三个其他的方法:

  • elements(): 返回一个迭代器,其中每个元素将重复出现计数值所指定次。 元素会按首次出现的顺序返回。 如果一个元素的计数值小于1,elements() 将会忽略它。
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> sorted(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
  • most_common([n]):返回前n个出现次数最多的元素及其计数,按计数值由高到低排序。 如果 n 被省略或为 None,most_common() 将返回计数器中的 所有元素。 计数值相等的元素按首次出现的顺序排序:
>>> Counter('abracadabra').most_common(3)
[('a', 5), ('b', 2), ('r', 2)]
  • subtract([iterable-or-mapping]):从 迭代对象 或 映射对象 减去元素。类似dict.update() ,但是是减去,而不是替换。输入和输出都可以是0或者负数。
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> d = Counter(a=1, b=2, c=3, d=4)
>>> c.subtract(d)
>>> c
Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

除了下述两个方法外,Counter拥有与dict一样的方法。

  • fromkeys(iterable): 这个类方法没有在 Counter 中实现。

  • update([iterable-or-mapping]): 从 迭代对象 计数元素或者 从另一个 映射对象 (或计数器) 添加。 像 dict.update() 但是是加上,而不是替换。另外,迭代对象 应该是序列元素,而不是一个 (key, value) 对。

Counter 的扩展用例
sum(c.values())                 # 求和全部的计数值
c.clear()                       # reset all counts
list(c)                         # list unique elements
set(c)                          # convert to a set
dict(c)                         # convert to a regular dictionary
c.items()                       # convert to a list of (elem, cnt) pairs
Counter(dict(list_of_pairs))    # convert from a list of (elem, cnt) pairs
c.most_common()[:-n-1:-1]       # 取前n个计数最小的元素
+c                              # 移除计数小于1的元素

支持几个数学操作,每种操作都可以接受带符号的计数,但是输出会忽略掉计数为零或者小于零的元素。

>>> c = Counter(a=3, b=1)
>>> d = Counter(a=1, b=2)
>>> c + d                       # add two counters together:  c[x] + d[x]
Counter({'a': 4, 'b': 3})
>>> c - d                       # subtract (keeping only positive counts)
Counter({'a': 2})
>>> c & d                       # intersection:  min(c[x], d[x]) 
Counter({'a': 1, 'b': 1})
>>> c | d                       # union:  max(c[x], d[x])
Counter({'a': 3, 'b': 2})

单个加和减(一元操作符)意味着从空计数器加或者减去。

>>> c = Counter(a=2, b=-4)
>>> +c
Counter({'a': 2})
>>> -c
Counter({'b': 4})

注解: Counter主要是为了表达元素的引用次数而设计;但是,也不用刻意排除使用了负数或其他值的用例。为了兼容这些用例,本小节规定了取值范围与类型。

  • 因为Counter 类是字典的一个子类,所以它的值不仅可以是整数,也可以是其他类型的值。
  • most_common() 方法仅在值需要排序的时候使用。
  • 赋值运算如 c[key] += 1 ,值的类型仅要求支持加法和减法。 所以值的类型可以是分数,小数,或者其他十进制数字,甚至负值也可以支持。这两个方法 update() 和 subtract() 的输入和输出也一样支持负数和0。
  • 多集方法虽然可以接受负数或者0,但只输出计数为正的值。输入的值没有类型限制,但值类型需要支持加,减和比较操作。(我没搞懂multiset methods是指这一类方法还是multiset方法,以后搞懂了再来修正)
  • elements() 方法要求正整数计数。忽略0和负数计数。

deque

class collections.deque([iterable[, maxlen]])

Deque是“double-ended queue”的简称,意为双向队列。若iterable没有指定,则返回队列为空。
Deque 可以从两端进行pop和append的操作,且时间复杂度均为O(1)。
如果 maxlen 没有指定或者是 None ,deques 可以增长到任意长度。否则,deque就限定到指定最大长度。一旦限定长度的deque满了,当新项加入时,同样数量的项就从另一端弹出。

双向队列(deque)对象支持以下方法:

  • append(x):添加 x 到右端。

  • appendleft(x):添加 x 到左端。

  • clear():移除所有元素,使其长度为0.

  • copy():创建一份浅拷贝。

  • count(x):计算 deque 中元素等于 x 的个数。

  • extend(iterable):扩展deque的右侧,通过添加iterable参数中的元素。

  • extendleft(iterable):扩展deque的左侧,通过添加iterable参数中的元素。注意,左添加时,在结果中iterable参数中的顺序将被反过来添加。

  • index(x[, start[, stop]]):返回 x 在 deque 中的位置(在索引 start 之后,索引 stop 之前)。 返回第一个匹配项,如果未找到则引发 ValueError。

  • insert(i, x):在位置 i 插入 x 。如果插入会导致deque 超出长度 maxlen 的话,就引发一个 IndexError。

  • pop():移去并且返回一个元素,deque 最右侧的那一个。 如果没有元素的话,就引发一个 IndexError。

  • popleft():移去并且返回一个元素,deque 最左侧的那一个。 如果没有元素的话,就引发 IndexError。

  • remove(value):移除找到的第一个 value。 如果没有的话就引发 ValueError。

  • reverse():将deque逆序排列。返回 None 。

  • rotate(n=1):向右循环移动 n 步。 如果 n 是负数,就向左循环。如果deque不是空的,向右循环移动一步就等价于 d.appendleft(d.pop()) , 向左循环一步就等价于 d.append(d.popleft()) 。

Deque对象同样提供了一个只读属性:

  • maxlen:Deque的最大尺寸,如果没有限定的话就是 None 。

除了以上操作,deque 还支持迭代、封存、len(d)、reversed(d)、copy.copy(d)、copy.deepcopy(d)、成员检测运算符 in 以及下标引用例如通过 d[0] 访问首个元素等。 索引访问在两端的复杂度均为 O(1) 但在中间则会低至 O(n)。 如需快速随机访问,请改用List。

示例:

>>> from collections import deque
>>> d = deque('ghi')                 # make a new deque with three items
>>> for elem in d:                   # iterate over the deque's elements
...     print(elem.upper())
G
H
I

>>> d.append('j')                    # add a new entry to the right side
>>> d.appendleft('f')                # add a new entry to the left side
>>> d                                # show the representation of the deque
deque(['f', 'g', 'h', 'i', 'j'])

>>> d.pop()                          # return and remove the rightmost item
'j'
>>> d.popleft()                      # return and remove the leftmost item
'f'
>>> list(d)                          # list the contents of the deque
['g', 'h', 'i']
>>> d[0]                             # peek at leftmost item
'g'
>>> d[-1]                            # peek at rightmost item
'i'

>>> list(reversed(d))                # list the contents of a deque in reverse
['i', 'h', 'g']
>>> 'h' in d                         # search the deque
True
>>> d.extend('jkl')                  # add multiple elements at once
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
>>> d.rotate(1)                      # right rotation
>>> d
deque(['l', 'g', 'h', 'i', 'j', 'k'])
>>> d.rotate(-1)                     # left rotation
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])

>>> deque(reversed(d))               # make a new deque in reverse order
deque(['l', 'k', 'j', 'i', 'h', 'g'])
>>> d.clear()                        # empty the deque
>>> d.pop()                          # cannot pop from an empty deque
Traceback (most recent call last):
    File "<pyshell#6>", line 1, in -toplevel-
        d.pop()
IndexError: pop from an empty deque

>>> d.extendleft('abc')              # extendleft() reverses the input order
>>> d
deque(['c', 'b', 'a'])
deque 的扩展用例

限长deque提供了类似Unix tail 过滤功能

def tail(filename, n=10):
    'Return the last n lines of a file'
    with open(filename) as f:
        return deque(f, n)

另一个用法是维护一个近期添加元素的序列,通过从右边添加和从左边弹出

def moving_average(iterable, n=3):
    # moving_average([40, 30, 50, 46, 39, 44]) --> 40.0 42.0 45.0 43.0
    # http://en.wikipedia.org/wiki/Moving_average
    it = iter(iterable)
    d = deque(itertools.islice(it, n-1))
    d.appendleft(0)
    s = sum(d)
    for elem in it:
        s += elem - d.popleft()
        d.append(elem)
        yield s / n

一个 轮询调度器 可以通过在 deque 中放入迭代器来实现。值从当前迭代器的位置0被取出并暂存(yield)。 如果这个迭代器消耗完毕,就用 popleft() 将其从对列中移去;否则,就通过 rotate() 将它移到队列的末尾

def roundrobin(*iterables):
    "roundrobin('ABC', 'D', 'EF') --> A D E B F C"
    iterators = deque(map(iter, iterables))
    while iterators:
        try:
            while True:
                yield next(iterators[0])
                iterators.rotate(-1)
        except StopIteration:
            # Remove an exhausted iterator.
            iterators.popleft()

rotate() 方法提供了一种方式来实现 deque 切片和删除。 例如, 一个纯的Python del d[n] 实现依赖于 rotate() 来定位要弹出的元素

def delete_nth(d, n):
    d.rotate(-n)
    d.popleft()
    d.rotate(n)

要实现 deque 切片, 使用一个类似的方法,应用 rotate() 将目标元素放到左边。通过 popleft() 移去老的条目(entries),通过 extend() 添加新的条目, 然后反向 rotate。这个方法可以最小代价实现命令式的栈操作,诸如 dup, drop, swap, over, pick, rot, 和 roll 。

defaultdict

class collections.defaultdict([default_factory[, …]])

返回一个新的类字典对象。defaultdict是dict的子类,增加了一个可选变量。其余的功能与dict类相同。

第一个参数default_factory的默认值为None。其余参数都像传递给dict一样处理。

除了标准的dict操作外,defaultdict对象还支持以下方法作为扩展:

  • __missing__(key):
    如果 default_factory 为 None,则调用本方法会抛出 KeyError 异常,附带参数 key。
    如果default_factory不是None,则会调用default_factory()来为 key 提供一个默认值,这个值和 key 作为一对键值对被插入到字典中,并作为本方法的返回值返回。(这里要理解function和function()的区别。)
    如果调用default_factory()时抛出了异常,这个异常会原封不动地向外层传递。
    在无法找到所需键值时,本方法会被 dict 中的 __getitem__() 方法调用。无论本方法返回了值还是抛出了异常,都会被 __getitem__() 传递。
    注意,__missing__() 不会被 __getitem__() 以外的其他方法调用。意味着 get() 会像正常的 dict 那样返回 None,而不是使用 default_factory。

defaultdict对象支持以下实例变量:

  • default_factory:本属性由 __missing__() 方法来调用。如果构造对象时提供了第一个参数,则本属性会被初始化成那个参数,如果未提供第一个参数,则本属性为 None。
defaultdict 扩展用例

把default_factory设置为list,很容易将键-值对序列分组到list字典中:

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = defaultdict(list)
>>> for k, v in s:
...     d[k].append(v)

>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

每当添加一个新的键时,便会调用设置的默工厂函数,返回一个空的列表。然后,通过list.append()操作将值添加到对应的列表里。当再次遇到相同的键时,list.append()操作将向该键对应的列表添加另一个值。这种方法比使用dict.setdefault()更简单和更快:

>>> d = {}
>>> for k, v in s:
...     d.setdefault(k, []).append(v)

>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

将default_factory设置为int可以使defaultdict用于计数(类似其他语言中的bag或multiset):

>>> s = 'mississippi'
>>> d = defaultdict(int)
>>> for k in s:
...     d[k] += 1

>>> sorted(d.items())
[('i', 4), ('m', 1), ('p', 2), ('s', 4)]

始终返回0的int()函数只是常量函数的一种特殊情况。创建常量函数的一个更快更灵活的方法是使用lambda函数,它可以提供任何常量值(不仅仅是零):

>>> def constant_factory(value):
...     return lambda: value
>>> d = defaultdict(constant_factory('<missing>'))
>>> d.update(name='John', action='ran')
>>> '%(name)s %(action)s to %(object)s' % d
'John ran to <missing>'

将default_factory设置为set使得defaultdict在构建集合字典时非常有用:

>>> s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
>>> d = defaultdict(set)
>>> for k, v in s:
...     d[k].add(v)

>>> sorted(d.items())
[('blue', {2, 4}), ('red', {1, 3})]

namedtuple()

命名元组赋予每个位置一个含义,提供可读性和自文档性。它们可以用于任何普通元组,并添加了通过名字获取值的能力,通过索引值也是可以的。

collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)

返回一个新的名为 typename的元组子类 。这个新的子类用于创建类似元组的对象,它不仅可以通过索引和迭代获取值,也可以通过字段名来获取属性值。

field_names 可以是一个像 [‘x’, ‘y’] 一样的字符串列表。另外 field_names 也可以是一个纯字符串,用空白或逗号分隔开元素名,比如 ‘x y’ 或者 ‘x, y’ 。

任何有效的Python 标识符都可以作为字段名,除了下划线开头的那些。有效标识符由字母,数字,下划线组成,但首字母不能是数字或下划线,另外不能是关键词 keyword 比如 class, for, return, global, pass, 或 raise 。

如果 rename 为True, 无效的字段名会自动转换成以位置命名。比如 [‘abc’, ‘def’, ‘ghi’, ‘abc’] 转换成 [‘abc’, ‘_1’, ‘ghi’, ‘_3’] , 移除了关键词 def 和重复字段名 abc 。

defaults 可以是 None ,也可以是一个可迭代对象 。如果defaults的长度小于命名域的长度,defaults 就被赋予到最右边的参数。比如如果域名 [‘x’, ‘y’, ‘z’] 和默认值 (1, 2) ,那么 x 就必须指定一个参数值 ,y 默认值 为1 , z 默认值为 2 。

如果 module 值有定义,命名元组的 module 属性值就被覆盖。

命名元组实例比起字典实例要更轻量,并且占用更小内存。

>>> # Basic example
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(11, y=22)     # instantiate with positional or keyword arguments
>>> p[0] + p[1]             # indexable like the plain tuple (11, 22)
33
>>> x, y = p                # unpack like a regular tuple
>>> x, y
(11, 22)
>>> p.x + p.y               # fields also accessible by name
33
>>> p                       # readable __repr__ with a name=value style
Point(x=11, y=22)

命名元组在给csv sqlite3 模块返回的元组赋值的时候尤其有用。

EmployeeRecord = namedtuple('EmployeeRecord', 'name, age, title, department, paygrade')

import csv
for emp in map(EmployeeRecord._make, csv.reader(open("employees.csv", "rb"))):
    print(emp.name, emp.title)

import sqlite3
conn = sqlite3.connect('/companydata')
cursor = conn.cursor()
cursor.execute('SELECT name, age, title, department, paygrade FROM employees')
for emp in map(EmployeeRecord._make, cursor.fetchall()):
    print(emp.name, emp.title)

除了继承元组的方法,命名元组还支持三个额外的方法和两个属性。为了防止字段名冲突,方法和属性以下划线开始。

  • classmethod somenamedtuple._make(iterable)
    类方法从存在的序列或迭代实例创建一个新实例。
>>> t = [11, 22]
>>> Point._make(t)
Point(x=11, y=22)
  • somenamedtuple._asdict()
    返回一个新的 dict ,它将字段名称映射到它们对应的值:
>>> p = Point(x=11, y=22)
>>> p._asdict()
{'x': 11, 'y': 22}
  • somenamedtuple._replace(**kwargs)
    返回一个新的命名元组实例,并将指定域替换为新的值
>>>
>>> p = Point(x=11, y=22)
>>> p._replace(x=33)
Point(x=33, y=22)

>>> for partnum, record in inventory.items():
...     inventory[partnum] = record._replace(price=newprices[partnum], timestamp=time.now())
  • somenamedtuple._fields
    字符串元组列出了字段名。用于提醒和从现有元组创建一个新的命名元组类型。
>>> p._fields            # view the field names
('x', 'y')

>>> Color = namedtuple('Color', 'red green blue')
>>> Pixel = namedtuple('Pixel', Point._fields + Color._fields)
>>> Pixel(11, 22, 128, 255, 0)
Pixel(x=11, y=22, red=128, green=255, blue=0)
  • somenamedtuple._field_defaults
    字典将字段名称映射到默认值。
>>> Account = namedtuple('Account', ['type', 'balance'], defaults=[0])
>>> Account._field_defaults
{'balance': 0}
>>> Account('premium')
Account(type='premium', balance=0)

要获取这个名字域的值,使用 getattr() 函数 :

>>> getattr(p, 'x')
11

转换一个字典到命名元组,使用 ** 两星操作符 (所述如 解包参数列表):

>>>
d = {'x': 11, 'y': 22}
Point(**d)
Point(x=11, y=22)

因为一个命名元组是一个正常的Python类,它可以很容易的通过子类更改功能。这里是如何添加一个计算域和定宽输出打印格式:

>>> class Point(namedtuple('Point', ['x', 'y'])):
...     __slots__ = ()
...     @property
...     def hypot(self):
...         return (self.x ** 2 + self.y ** 2) ** 0.5
...     def __str__(self):
...         return 'Point: x=%6.3f  y=%6.3f  hypot=%6.3f' % (self.x, self.y, self.hypot)

>>> for p in Point(3, 4), Point(14, 5/7):
...     print(p)
Point: x= 3.000  y= 4.000  hypot= 5.000
Point: x=14.000  y= 0.714  hypot=14.018

上面的子类设置 __slots__ 为一个空元组。通过阻止创建实例字典保持了较低的内存开销。

子类化对于添加和存储新的名字域是无效的。应当通过 _fields 创建一个新的命名元组来实现它:

Point3D = namedtuple('Point3D', Point._fields + ('z',))

文档字符串可以自定义,通过直接赋值给 __doc__ 属性:

Book = namedtuple('Book', ['id', 'title', 'authors'])
Book.__doc__ += ': Hardcover book in active collection'
Book.id.__doc__ = '13-digit ISBN'
Book.title.__doc__ = 'Title of first printing'
Book.authors.__doc__ = 'List of authors sorted by last name'

OrderedDict

有序词典就像常规词典一样,但有一些与排序操作相关的额外功能。由于内置的 dict 类获得了记住插入顺序的能力(在 Python 3.7 中保证了这种新行为),它们变得不那么重要了。

class collections.OrderedDict([items])

返回一个 dict 子类的实例,它具有专门用于重新排列字典顺序的方法。

  • popitem(last=True):有序字典的 popitem() 方法移除并返回一个 (key, value) 键值对。 如果 last 值为真,则按 LIFO 后进先出的顺序返回键值对,否则就按 FIFO 先进先出的顺序返回键值对。

  • move_to_end(key, last=True):将现有 key 移动到有序字典的任一端。 如果 last 为真值(默认)则将元素移至末尾;如果 last 为假值则将元素移至开头。如果 key 不存在则会触发 KeyError:

>>> d = OrderedDict.fromkeys('abcde')
>>> d.move_to_end('b')
>>> ''.join(d.keys())
'acdeb'
>>> d.move_to_end('b', last=False)
>>> ''.join(d.keys())
'bacde'

相对于通常的映射方法,有序字典还另外提供了逆序迭代的支持,通过 reversed() 。

OrderedDict 之间的相等测试是顺序敏感的,实现为 list(od1.items())==list(od2.items()) 。 OrderedDict 对象和其他的 Mapping 的相等测试,是顺序敏感的字典测试。这允许 OrderedDict 替换为任何字典可以使用的场所。

OrderedDict 的扩展用例

创建记住键值 最后 插入顺序的有序字典变体很简单。 如果新条目覆盖现有条目,则原始插入位置将更改并移至末尾:

class LastUpdatedOrderedDict(OrderedDict):
    # 'Store items in the order the keys were last added'

    def __setitem__(self, key, value):
        super().__setitem__(key, value)
        self.move_to_end(key)

一个 OrderedDict 对于实现 functools.lru_cache() 的变体也很有用:

class LRU(OrderedDict):
    # 'Limit size, evicting the least recently looked-up key when full'

    def __init__(self, maxsize=128, /, *args, **kwds):
        self.maxsize = maxsize
        super().__init__(*args, **kwds)

    def __getitem__(self, key):
        value = super().__getitem__(key)
        self.move_to_end(key)
        return value

    def __setitem__(self, key, value):
        if key in self:
            self.move_to_end(key)
        super().__setitem__(key, value)
        if len(self) > self.maxsize:
            oldest = next(iter(self))
            del self[oldest]
Google Collections:Java开发者必备的集合处理库Guava教程 本文还有配套的精品资源,点击获取 简介:谷歌集合框架(Google Collections),即现在的Guava库,是一个为Java开发者设计的扩展集合框架库。它提供了新的数据结构和实用工具类,如Multiset、Multimap、Immutable Collections、BiMap、Predicate和Function等,以及丰富的方法和函数式编程的支持,包括扩展的列表... 阅读详情

相关推荐

实战解析:从Innovus到Calibre的LVS错误排查全流程

本文详细解析了从Innovus到Calibre的LVS错误排查全流程,涵盖物理验证关键步骤与工具链协同。通过实战案例分享,重点解决器件不匹配、连接性错误等常见问题,并提供GDS导出规范、网表修正策略等实用技巧,帮助工程师高效完成芯片设计物理验证。

9o8p7i6u5y的博客 1038

数据库一对多查询collection的用法

数据库一对多查询 注意resultMap不能重复 colum是主表的Id字段 select file_id, storage_id, file_text from sys_warehouse_file storage_id = #{storageId}

Too_seeyou的博客 973

用豆包+Skill从零制作AI漫剧:分镜、画面、配音到成片全流程

AI漫剧作为一种新兴内容形态,结合AI绘画与AI视频生成技术,正在改变短视频创作方式。其核心原理是利用提示词工程,将创意转化为结构化分镜脚本,再通过豆包等AI助手的Skill能力,将重复的脚本生成和分镜拆解流程固化为可复用的指令模板,从而大幅降低从构思到成品的生产门槛。这种模式无需剧组、演员和实景拍摄,让个人创作者也能借助图像生成、TTS配音与剪辑合成工具,批量化地生产剧情短片,适用于短视频平台连载、商业定制与个人IP打造。围绕豆包+Skill这条主线,从选题、剧本写作、分镜表设计,到画面提示词生成、视频片

weixin_29048309的博客 1560

MongoDB--数据库与Collection注意事项

注意事项: 1、数据库名注意应该全部小写,不能包含空格,最大长度为64K名称 2、数据库存储为多个文件,库名:Per ,文件:Per1、Per2 等,库名:Sun ,文件:Sun1、Sun2 等,但是单个文件最大为2G 3、集合和索引对应的命名空间元数据保存在.ns文件中 表: 1、存储的数据字段为强类型,“age”与“Age”是两个不同的属性 2、同一行数据的列明不能重复

一只小羊的专栏 1314

汽车诊断服务(UDS——0x11服务解析)

ECU复位服务(0x11)详解:该服务支持硬件/钥匙开关/软件三种复位类型(0x01-0x03),复位前需发送肯定响应。请求格式为11+子功能,响应含51+子功能。典型应用需配合安全访问流程,测试时需监控CAN总线通信及DTC状态。复位后ECU将返回默认会话,期间不处理任何诊断请求。服务在编程会话且安全解锁后执行,硬复位会初始化存储数据。

从事汽车行业 980

Swift Package Manager (SPM) 创建并集成本地库

Swift Package Manager (SPM) 在macOS 项目中创建并集成的完整步骤

征战无悔人生 1428

mongodb 中 获取指定数据库中所有collection(表)的记录数,表的大小

lists = db.getCollectionNames();for(i in lists){print(lists[i]+" --- "+db[lists[i]].stats().count+" ... "+db[lists[i]].stats().size)} ...

chouyada5278的博客 2993

Tessent ATPG进阶:解锁多种Fault Model的工程实践与选型指南

本文深入探讨Tessent ATPG中多种Fault Model的工程实践与选型策略,涵盖Stuck-at、Transition、Bridge等核心模型的应用场景与配置技巧。通过实际案例解析,展示如何组合不同Fault Model提升芯片测试覆盖率,特别针对汽车电子、超低功耗芯片等复杂场景提供专业解决方案。

weixin_30219613的博客 200

Collections类详解

Java

qq_50692350的博客 1万+

YOLOv8 置信度阈值 (conf) 和 IoU 阈值 (iou) 详解:如何平衡漏检与误检?

摘要 本文深入探讨了YOLOv8目标检测模型中两个关键参数——置信度阈值(conf)和IoU阈值(iou)的核心作用。文章从目标检测的基础概念出发,解释了置信度分数反映模型预测可靠性,IoU衡量预测框重叠程度。重点剖析了非极大值抑制(NMS)机制如何通过这两个阈值进行预测框筛选:置信度阈值作为初筛门槛,IoU阈值决定重叠框的取舍。通过生动比喻和可视化图表,阐述了合理调节这两个参数能有效平衡误检与漏检问题,是优化YOLOv8模型实际表现的重要技巧。全文以实践为导向,帮助开发者掌握成为"调参大师&qu

深耕 Vue 生态与 JS/TS 技术,聚焦组件封装、响应式原理、TS 类型设计,解析工程化配置与性能优化方案。同时分享 YOLOv8 目标检测实战、AI 大模型面试核心考点,以代码实例拆解技术实现与业务解法。 1259

IEC61850规约客户端软件开发实战(第六章)

IEC 61850标准中的GOOSE(Generic Object Oriented Substation Event,面向通用对象的变电站事件)功能是变电站自动化系统的核心通信机制,主要用于实现智能电子设备(IED)间高可靠性、低延时的实时信号传输。本章简述其核心功能与技术特点。

半青年的博客 1780

算法导论第十四章:数据结构的扩展

这章的主要内容是通过红黑树的两个扩展例子掌握如何对一种数据结构在原有基础上进行扩展。 来为自己所用 扩展一种数据结构大致可以分为4个步骤: 1.选择一种基础数据结构. 2.确定基础数据结构中要维护的附加信息. 3.检验基础数据结构中的基本操作能否维护附加信息 4.设计一些新操作 一.顺序统计树 它是红黑树的一个修改,它可以在 O(lgn) 时间内确定任何的顺序统计量。 相比于前面的运用快排思想的顺...

c1776167012的博客 558

MVDR算法: 自适应波束形成在信号处理领域中扮演着重要的角色。本文将介绍MVDR(最小方差无失真响应)算法,并提供相应的Matlab源代码实现。

MVDR算法是一种用于抑制干扰信号并增强感兴趣信号的自适应波束形成算法。它的基本思想是通过对干扰信号进行空间滤波,使其在感兴趣信号方向上的输出功率最小化。这种方法可以提高信号的质量和可辨识度,特别是在存在多个干扰源的复杂环境中。本文将介绍MVDR(最小方差无失真响应)算法,并提供相应的Matlab源代码实现。使用MVDR算法,我们可以通过对观测信号进行波束形成来抑制干扰信号并增强感兴趣信号。以上是MVDR算法的Matlab实现。的每一列代表一个阵列元素的观测信号。表示期望的波束指向,即感兴趣信号的方向。

HackWhisper的博客 1247

Collections-C自定义数据结构:扩展库功能的高级技巧

Collections-C是一个为C语言提供通用数据结构的强大库,它允许开发者轻松实现高效的集合操作。本文将分享3个实用的高级技巧,帮助你充分利用这个库的自定义功能,打造更适合特定场景的数据结构解决方案。 ## 一、掌握配置结构体:定制数据结构的第一步 每个数据结构都提供了配置结构体(`*_conf_s`),这是自定义的核心入口。以哈希表为例,`CC_HashTableConf`结构体包含了负

gitblog_00344的博客 333

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

Redis Collections使用手册

Redis Collections使用手册 1. 项目目录结构及介绍 Redis Collections 是一个扩展库,旨在提供高级数据结构接口给 Redis,使得开发者能够更便捷地在 Redis 中操作类似传统编程语言中的集合类型。以下是此项目的基本目录结构及其简介: redis-collections/ ├── LICENSE.txt # 许可证文件,描述软件使用的版权协议。 ...

gitblog_00357的博客 359

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Java collections framework(Java容器框架)(基于维基百科补充)

Java collections framework From Wikipedia, the free encyclopedia Jump to: navigation, search class- and interface hierarchy of java.util.Map The Java collections framework (JCF)

ajian005的专栏 2656

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

[转]Java集合框架之fastutil

重点:首先从宏观上,fastutil是个集合框架,和jdk里的map/set一样。然后业界多有扩展、增强、优化。fastutil是其中一样,在我们的项目里,用到了fastutil和guava。 fastutil之外,主要的 JDK集合框架的扩展还有以下这么多,他们都各自有各自的特点,各有所长: Apache Commons Collections Apache Commons Primitives Google Guava Trove Huge Collections Joda Primitives Jav

见端而知末 1346

Swift Collections 终极指南:10个提升开发效率的数据结构宝库

🚀 **Swift Collections** 是苹果官方推荐的常用数据结构扩展库,为 Swift 标准库提供了缺失但至关重要的数据结构支持。这个开源项目通过优化的内存布局和算法设计,显著提升了 Swift 开发效率和性能表现。 ## 为什么需要 Swift Collections? Swift 标准库虽然强大,但在某些复杂数据结构方面存在不足。Swift Collections 填补了这一

gitblog_00131的博客 382

Zed 的 Parallel Agents 怎么用 Git Worktree 隔离多个 Agent 线程?

当你同时让多个 Agent 线程干活时,最容易踩的坑是两个线程改到同一批文件,互相覆盖彼此的修改。Zed 的 Parallel Agents 功能允许从 Threads Sidebar 同时运行多个 Agent 线程和 Terminal Threads,每个线程拥有独立的 Agent、上下文窗口和对话历史;当两个线程可能编辑相同文件时,官方给出的隔离手段是把其中一个线程放进新建的 Git work

gitblog_00366的博客 330

Google Guava Collections 使用介绍

Google Guava Collections 是一个对 Java Collections Framework 增强和扩展的一个开源项目。由于它高质量 API 的实现和对 JDK5 特性的充分利用,使得其在 Java 社区受到很高评价。笔者主要介绍它的基本用法和功能特性。        Google Guava Collections 使用介绍 Google Guava Collec

西楚小羽的专栏 1914

SDR++ 新手指南:从接上 RTL-SDR 到听见第一声广播

SDR++ 是一款跨平台的开源软件定义无线电(SDR)应用。把 USB 接收棒插进电脑,你就能收 FM 广播、航空语音,甚至气象卫星图像。这份中文教程带你从选硬件、装软件,一直走到收到第一声台。 ## 🔌 硬件先行:选棒、装驱动 这一步解决两个问题:买哪根 USB 接收棒,装哪个驱动库。 常用接收棒有三款,各自对应一个驱动库: | 接收棒 | 特点 | 驱动库 | 建议采样率 | |--

gitblog_00779的博客 750

Commons Collections,一款很酷的Java工具库

介绍Apache Commons Collections的功能与使用

黑马非马的博客 1万+

Google Guava Collections

Google Guava Collections 使用介绍 Google Guava Collections(以下都简称为 Guava Collections)是 Java Collections Framework 的增强和扩展。每个 Java 开发者都会在工作中使用各种数据结构,很多情况下 Java Collections Framework 可以帮助你完成这类工作。但是在有些场合你使用

july_2的专栏 1129
上一篇: 《Redis in Action》——不仅仅是缓存 部分翻译
下一篇: itertools ——为高效循环而创建迭代器的函数
调皮博士
博客等级 码龄10年 14粉丝 15原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值