标签: python-collections

在Python 3中,我需要测试我的变量是否具有类型'dict_items',所以我尝试了类似的东西:

>>> d={'a':1,'b':2}
>>> d.items()
dict_items([('a', 1), ('b', 2)])
>>> isinstance(d.items(),dict_items)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'dict_items' is not defined

但dict_items不是一个已知的类型.它没有在types模块中定义.如何测试具有类型的对象dict_items(不消耗数据)？

我目前使用defaultdict的Counter唯一指望的不可预知的钥匙几个不可预测值:

from collections import defaultdict, Counter

d = defaultdict(Counter)
d['x']['b'] += 1
d['x']['c'] += 1
print(d)

这给了我预期的结果:

defaultdict(<class 'collections.Counter'>, {'x': Counter({'c': 1, 'b': 1})})

我现在需要扩展其中的值的结构,defaultdict并dict使用两个键来创建它:前一个Counter和一个str:

mystruct = {
    'counter': collections.Counter(),
    'name': ''
}

是否有可能使用特定的数据结构(如上述),作为default_factory在defaultdict？预期的结果是,对于每个不存在的键,defaultdict将创建一个用上面的结构初始化的新键和值.

Python Collection Counter.most_common(n)方法返回前n个元素及其计数。但是，如果两个元素的计数相同，如何返回按字母顺序排序的结果？

例如：对于像这样的字符串BBBAAACCD，对于“最常见的2个”元素，我希望结果是指定的n = 2：

[('A', 3), ('B', 3), ('C', 2)]

并不是：

[('B', 3), ('A', 3), ('C', 2)]

请注意，虽然A与B具有相同的频率，A来之前B，因为它到来之前在结果列表中B按字母顺序排列。

[('A', 3), ('B', 3), ('C', 2)]

我该如何实现？

我需要Python中的bag / multiset-like数据类型。我了解collections.Counter通常用于此目的。但是比较运算符似乎不起作用：

In [1]: from collections import Counter

In [2]: bag1 = Counter(a=1, b=2, c=3)

In [3]: bag2 = Counter(a=2, b=2)

In [4]: bag1 > bag2
Out[4]: True

对我来说，这似乎是一个错误。我期望小于和大于运算符执行类似集合的子集和超集比较。但是，如果真是这样，那bag1 > bag2将是错误的，因为bag2其中包含一个额外的'a'。Counter对象上似乎也没有子集/超集方法。所以我有两个问题：

1. 计数器对象使用什么比较逻辑？
2. 如何比较计数器对象的子集，超集，适当子集和适当超集？

模块中的某些元素collections似乎是大写的，而另一些则不是。其背后是否有具体的理由？

Python集合计数器好奇,如果有更好的方法来做到这一点.重写Counter类方法？内置乘法产生两个计数器的点积

from collections import Counter
a = Counter({'b': 4, 'c': 2, 'a': 1})
b = Counter({'b': 8, 'c': 4, 'a': 2})    
newcounter = Counter()
for x in a.elements():
    for y in b.elements():
        if x == y:
             newcounter[x] = a[x]*b[y]

$ newcounter
Counter({'b': 32, 'c': 8, 'a': 2})

我有一个交通灯枚举定义可能的状态:

class TrafficLightPhase(Enum):
    RED = "RED"
    YELLOW = "YELLOW"
    GREEN = "GREEN"

我轮询一个交通信号灯每秒获取当前状态,然后我将这些值放入a deque函数中:

def read_phases():
    while running:
        current_phase = get_current_phase_phases()
        last_phases.append(current_phase)
        time.sleep(1)

我想对相同状态的序列进行分组,以便了解交通信号灯的相位时序.

我尝试使用Counter类collections,如下所示:

counter = collections.Counter(last_phases)

它组合了很好的不同状态,但我不知道下一个周期何时开始.是否有类似的数据结构Counter允许重复？所以我可以得到如下结果:

Counter({
         'RED': 10,
         'GREEN': 10, 
         'YELLOW': 3,
         'RED': 10,
         'GREEN': 10, 
         'YELLOW': 3,
         'RED': 10,
         'GREEN': 10, 
         'YELLOW': 3
        })

而不是:反击({'RED':30,'GREEN':30,'YELLOW':9})

以下代码使用 {} 运算符组合两个 defaultdict。

from collections import defaultdict
aa=defaultdict(str)
bb=defaultdict(str)
aa['foo']+= '1'
bb['bar']+= '2'
cc = {**aa,**bb}
type(cc)

但是，正如我们看到的，如果我们运行它，{}操作符返回一个dict类型而不是一个defaultdict类型。

有没有办法将dict返回到 defaultdict ？

给定一个字符串:

this is a test this is

我怎样才能找到最常见的2克？在上面的字符串中,所有2克都是:

{this is, is a, test this, this is}

你可以注意到,2克this is出现了2次.因此结果应该是:

{this is: 2}

我知道我可以使用Counter.most_common()方法来查找最常见的元素,但是如何从字符串开始创建一个2-gram的列表呢？

在 python 中，当我将集合转换为列表时，此类任务的算法复杂度是多少？它只是对集合进行类型转换，还是需要将项目复制到不同的数据结构中？发生了什么？

我很想知道复杂性是恒定的，就像 Python 中的许多东西一样。