Python 在不使用集合的情况下计数事件。计数器

我正在尝试检索列表中频率最高和频率较低的元素

frequency([13,12,11,13,14,13,7,11,13,14,12,14,14])

我的输出是：

([7], [13, 14])

我试了一下：

import collections
s = [13,12,11,13,14,13,7,11,13,14,12,14,14]
count = collections.Counter(s)
mins = [a for a, b in count.items() if b == min(count.values())]
maxes = [a for a, b in count.items() if b == max(count.values())]
final_vals = [mins, maxes]

但是我不想使用

collections

模块，尝试一种更面向逻辑的解决方案。

---

你能帮我做这件事吗

您可以使用

尝试
和
除
外的
方法，使用
dict
模拟
计数器

data = [13,12,11,13,14,13,7,11,13,14,12,14,14]
occurrences = {}
for i in data:
     if i in occurrences.keys():
             occurrences[i] += 1
     else:
             occurrences[i] = 1

max_vals = [i for i in occurrences.keys() if occurrences[i] == max(occurrences.values())]
min_vals = [i for i in occurrences.keys() if occurrences[i] == min(occurrences.values())]

def counter(it):
    counts = {}
    for item in it:
        try:
            counts[item] += 1
        except KeyError:
            counts[item] = 1
    return counts

或者，您也可以使用默认值
0
：

def counter(it):
    counts = {}
    for item in it:
        counts[item] = counts.get(item, 0) + 1
    return counts

您应该在理解之外执行
min（）
和
max（）
，以避免重复计算该数量（函数现在是
O（n）
，而不是
O（n^2）
：

这将如预期的那样起作用：

>>> minimum_and_maximum_frequency(counter([13,12,11,13,14,13,7,11,13,14,12,14,14]))
([7], [13, 14])

您可以使用
try
和
except
方法和
dict
模拟
计数器

def counter(it):
    counts = {}
    for item in it:
        try:
            counts[item] += 1
        except KeyError:
            counts[item] = 1
    return counts

或者，您也可以使用默认值
0
：

def counter(it):
    counts = {}
    for item in it:
        counts[item] = counts.get(item, 0) + 1
    return counts

您应该在理解之外执行
min（）
和
max（）
，以避免重复计算该数量（函数现在是
O（n）
，而不是
O（n^2）
：

这将如预期的那样起作用：

>>> minimum_and_maximum_frequency(counter([13,12,11,13,14,13,7,11,13,14,12,14,14]))
([7], [13, 14])

collections
中的
defaultdict
更适合替换
计数器
，以计算列表中项目的出现次数。但由于您限制了
collections
的使用。因此
setdefault
在处理
keyrerror
时更加优雅

collections
中的
defaultdict
更适合替换
计数器
，以计算列表中项目的出现次数。但由于您限制了
集合的使用
。因此
setdefault
在处理
keyrerror
时更加优雅

s = [13,12,11,13,14,13,7,11,13,14,12,14,14]
freq_low = s.count(min(s, key=s.count))
freq_high = s.count(max(s, key=s.count))
mins = [a for a in set(s) if s.count(a) == freq_low]
maxes = [a for a in set(s) if s.count(a) == freq_high]
final_vals = [mins, maxes]

这个怎么样：

s = [13,12,11,13,14,13,7,11,13,14,12,14,14]
freq_low = s.count(min(s, key=s.count))
freq_high = s.count(max(s, key=s.count))
mins = [a for a in set(s) if s.count(a) == freq_low]
maxes = [a for a in set(s) if s.count(a) == freq_high]
final_vals = [mins, maxes]

这是一个非常简单的解决方案，可能不是最有效的解决方案（？），而是一个简单的解决方案

data = get_data()
freqs, numbers = {}, {}
for i in data:
    freqs[i] = freqs.get(i, 0) + 1
for n, c in freqs.items():
    numbers[c] = numbers.get(c, []) + [n]
counts = list(numbers.keys())
res = (numbers[min(counts)], numbers[max(counts)])

让我们详细了解一下上面脚本中的内容，让我们从
您给出的示例数据

In [1]: data = [13,12,11,13,14,13,7,11,13,14,12,14,14]

我们将使用两本字典

In [2]: freqs, numbers = {}, {}

第一个是在
数据
上迭代填充的，其键是
数据中的单个数字及其值表示每个数字的频率
数据中的数字（参见fotnote了解
freqs.get（…）
）

第二个简单地与第一个相反，关键是
频率和值是具有给定值的数字列表
频率

In [4]: for n, c in freqs.items(): numbers[c] = numbers.get(c, []) + [n]

In [5]: numbers
Out[5]: {1: [7], 2: [12, 11], 4: [13, 14]}

此时，我们需要一个带有
数字键的列表，即
事件

In [6]: counts = list(numbers.keys())

In [7]: [numbers[min(counts)], numbers[max(counts)]]
Out[7]: [[7], [13, 14]]

因为我们对最小值和最大值感兴趣
事件

In [6]: counts = list(numbers.keys())

In [7]: [numbers[min(counts)], numbers[max(counts)]]
Out[7]: [[7], [13, 14]]


脚注：字典的
.get（键，默认值）
方法
如果字典中不存在键，则返回默认值，
我们将此功能与
0
默认值一起使用，以对发生的事件求和
单个编号，并使用
[]
，创建一个无效列表
在所有给定频率的数字中。
这是一个非常简单的解决方案，可能不是最有效的解决方案（？），而是一个简单的解决方案

data = get_data()
freqs, numbers = {}, {}
for i in data:
    freqs[i] = freqs.get(i, 0) + 1
for n, c in freqs.items():
    numbers[c] = numbers.get(c, []) + [n]
counts = list(numbers.keys())
res = (numbers[min(counts)], numbers[max(counts)])

In [4]: for n, c in freqs.items(): numbers[c] = numbers.get(c, []) + [n]

In [5]: numbers
Out[5]: {1: [7], 2: [12, 11], 4: [13, 14]}

让我们详细了解一下上面脚本中的内容，让我们从
您给出的示例数据

In [1]: data = [13,12,11,13,14,13,7,11,13,14,12,14,14]

我们将使用两本字典

In [2]: freqs, numbers = {}, {}

第一个是在
数据
上迭代填充的，其键是
数据中的单个数字及其值表示每个数字的频率
数据中的数字（参见fotnote了解
freqs.get（…）
）

第二个简单地与第一个相反，关键是
频率和值是具有给定值的数字列表
频率

In [4]: for n, c in freqs.items(): numbers[c] = numbers.get(c, []) + [n]

In [5]: numbers
Out[5]: {1: [7], 2: [12, 11], 4: [13, 14]}

此时，我们需要一个带有
数字键的列表，即
事件

In [6]: counts = list(numbers.keys())

In [7]: [numbers[min(counts)], numbers[max(counts)]]
Out[7]: [[7], [13, 14]]

因为我们对最小值和最大值感兴趣
事件

In [6]: counts = list(numbers.keys())

In [7]: [numbers[min(counts)], numbers[max(counts)]]
Out[7]: [[7], [13, 14]]


脚注：字典的
.get（键，默认值）
方法
如果字典中不存在键，则返回默认值，
我们将此功能与
0
默认值一起使用，以对发生的事件求和
单个编号，并使用
[]
，创建一个无效列表
在给定频率的所有数字中。
对于“最大占用元素”（又名.mode），请看这个问题：。对于“最大占用元素”（又名.mode），请看这个问题：。可能的重复是
O（n^4）
（或者可能只是
O（n^3）
），而问题可以在
O（n）中轻松解决
。这是
O（n^4）
（或者可能只是
O（n^3）
），而问题可以在
O（n）
中轻松解决。可能不是最快的一步，但每一步（计数、集总和查找键的极值）都是
O（n）
，因此总的复杂性仍然是
O（n）
…可能不是最快的一步，但每一步都是最快的一步（计数、集总和查找键的极值）是
O（n）
，因此总的复杂性仍然是
O（n）
…
In [4]: for n, c in freqs.items(): numbers[c] = numbers.get(c, []) + [n]

In [5]: numbers
Out[5]: {1: [7], 2: [12, 11], 4: [13, 14]}