python向量元素的计数

我想在向量

a

中计算并保存大于某个值

t

的数组元素数。我想对不同的

t

s执行此操作

乙二醇

我的向量：

c=[0.3 0.2 0.3 0.6 0.9 0.1 0.2 0.5 0.3 0.5 0.7 0.1]

我想计算

c

中大于

t=0.9

的元素数，大于

t=0.8

大于

t=0.7

的元素数等等。。。然后我想保存向量中t的每个不同值的计数

我的代码是（不工作）：

我的向量a应该是10维的，但它不是

有人能帮我吗？

你的问题是：

如果c[j]>t/10:

请注意，t和10都是整数，因此执行整数除法。 更改最少的最简单解决方案是将其更改为：

如果c[j]>float（t）/10:

强制浮动除法

所以整个代码看起来像这样：

a = []
c = [0.3, 0.2, 0.3, 0.6, 0.9, 0.1, 0.2, 0.5, 0.3, 0.5, 0.7, 0.1]
for i in range(10): #10 is our 1.0 change it to 9 if you want to iterate to 0.9
    sum = 0
    cutoff = float(i)/10
    for ele in c:
        if ele <= cutoff:
            sum += ele
    a.append(sum)
print(len(a)) # prints 10, the numbers from 0.0 - 0.9
print(a) # prints the sums going from 0.0 cutoff to 1.0 cutoff

a=[]
c=[0.3,0.2,0.3,0.6,0.9,0.1,0.2,0.5,0.3,0.5,0.7,0.1]
对于范围（10）中的i:#10是我们的1.0，如果要迭代到0.9，请将其更改为9
总和=0
截止=浮动（i）/10
对于c中的ele：
如果ele必须除以t/10.0，因此结果为十进制，则t/10的结果为整数

a = []
c=[0.3, 0.2, 0.3, 0.6, 0.9, 0.1, 0.2, 0.5, 0.3, 0.5, 0.7, 0.1]
for t in range(0,10,1):
    count = 0
    for j in range(0, len(c)):
        if c[j]>t/10.0:
            count = count+1
    a.append(count)
for t in range(0,10,1):
    print(str(a[t]) + ' elements in c are bigger than ' + str(t/10.0))

输出：

12 elements in c are bigger than 0.0
10 elements in c are bigger than 0.1
8 elements in c are bigger than 0.2
5 elements in c are bigger than 0.3
5 elements in c are bigger than 0.4
3 elements in c are bigger than 0.5
2 elements in c are bigger than 0.6
1 elements in c are bigger than 0.7
1 elements in c are bigger than 0.8
0 elements in c are bigger than 0.9

[12 10  8  5  5  3  2  1  1  0]

您可以检查测试
我制作了一个函数，该函数在数组上循环，只要值大于提供的阈值，就进行计数

c=[0.3, 0.2, 0.3, 0.6, 0.9, 0.1, 0.2, 0.5, 0.3, 0.5, 0.7, 0.1]

def num_bigger(threshold):
    count = 0
    for num in c:
        if num > threshold:
            count +=1

    return count

thresholds = [x/10.0 for x in range(10)]

for thresh in thresholds:
    print thresh, num_bigger(thresh)

请注意，该函数检查严格意义上的更大值，这就是为什么，例如，当阈值为.9时，结果为0
 如果简化代码，bug就没有藏身之处了

c=[0.3, 0.2, 0.3, 0.6, 0.9, 0.1, 0.2, 0.5, 0.3, 0.5, 0.7, 0.1]    
a=[]    
for t in [x/10 for x in range(10)]:
    a.append((t,len([x for x in c if x>t])))

a
[(0.0, 12),
 (0.1, 10),
 (0.2, 8),
 (0.3, 5),
 (0.4, 5),
 (0.5, 3),
 (0.6, 2),
 (0.7, 1),
 (0.8, 1),
 (0.9, 0)]

甚至这一行

[(r/10,len([x for x in c if x>r/10])) for r in range(10)]

您的代码几乎没有什么问题

我的向量a应该是10维的，但它不是

这是因为您不会在列表中只追加10个元素。看看你的逻辑

for t in range(0,10,1):
    for j in range(0, len(c)):    
        if c[j]>t/10:
            a.append(sum(c[j]>t))

对于每个阈值，
t
，您一次迭代
c
中的所有12个项目，并向列表中添加一些内容。总的来说，你可以得到120件物品。您应该做的是（在伪代码中）：

numpy.where（）
提供满足条件的数组中的索引，因此您只需计算每次获得的索引数。我们会找到完整的解决方案的

另一个潜在错误是
t/10
，它在Python 2中是整数除法，对于所有阈值都返回0。正确的方法是使用
t/10强制浮点除法。
。不过，如果您使用的是Python 3，那么默认情况下会使用浮点除法，所以这可能不是问题。请注意，您确实执行了
c[j]>t
，其中
t
介于0和10之间。总的来说，您的
c[j]>t
逻辑是错误的。您希望对所有元素使用计数器，就像其他答案向您展示的那样，或者将其全部折叠为一行列表

最后，这里有一个充分利用numpy的解决方案

import numpy as np

c = np.array([0.3, 0.2, 0.3, 0.6, 0.9, 0.1, 0.2, 0.5, 0.3, 0.5, 0.7, 0.1])

thresh = np.arange(0, 1, 0.1)
counts = np.empty(thresh.shape, dtype=int)

for i, t in enumerate(thresh):
    counts[i] = len(np.where(c > t)[0])

print counts

输出：

12 elements in c are bigger than 0.0
10 elements in c are bigger than 0.1
8 elements in c are bigger than 0.2
5 elements in c are bigger than 0.3
5 elements in c are bigger than 0.4
3 elements in c are bigger than 0.5
2 elements in c are bigger than 0.6
1 elements in c are bigger than 0.7
1 elements in c are bigger than 0.8
0 elements in c are bigger than 0.9

[12 10  8  5  5  3  2  1  1  0]

让numpy处理引擎盖下的循环比Python级别的循环要快。用于演示：

import timeit

head = """
import numpy as np

c = np.array([0.3, 0.2, 0.3, 0.6, 0.9, 0.1, 0.2, 0.5, 0.3, 0.5, 0.7, 0.1])

thresh = np.arange(0, 1, 0.1)
"""

numpy_where = """
for t in thresh:
    len(np.where(c > t)[0])
"""

python_loop = """
for t in thresh:
    len([element for element in c if element > t])
"""

n = 10000

for test in [numpy_where, python_loop]:
    print timeit.timeit(test, setup=head, number=n)

这在我的计算机上会导致以下计时

0.231292377372
0.321743753994

它取决于数组的大小，但您当前的解决方案具有
O（m*n）
复杂性，
m
是要测试的值的数量，
n
是数组的大小。使用
O（（m+n）*log（n））
可能会更好，方法是首先在
O（n*log（n））
中对数组排序，然后使用二进制搜索在
O（m*log（n））中查找
m
值。使用numpy和示例
c
列表，这将类似于：

>>> c
[0.3, 0.2, 0.3, 0.6, 0.9, 0.1, 0.2, 0.5, 0.3, 0.5, 0.7, 0.1]
>>> thresholds = np.linspace(0, 1, 10, endpoint=False)
>>> thresholds
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

>>> len(c) - np.sort(c).searchsorted(thresholds, side='right')
array([12, 10,  8,  5,  5,  3,  2,  1,  1,  0])

你想从.9数到0吗？是的！但是我想如果我从0数到0.9，它应该不会改变，这种方法应该更简单，我可以使用range（）命令，你所有的
c
值都在
[0,1]
区间内？是的，
c
的任何元素都不在
[0,1]
区间之外。它仍然在做错误的事情。我检查的第一件事是
a
的维度，应该是10；对于每一个
t
，我想知道
c
的元素有多少大于
t
。我想我理解你现在的要求，那只是最外层循环中的一个变化，在数字0.0-0.9（或1.0）上迭代，我不确定是哪个。a
的所有元素都有相同的值，这是错误的。对于大于某个
t
变量的
c
元素计数的
t
的每个值，a中的元素是不同的，请检查编辑的答案和测试代码的链接。不清楚OP是否在Python 3上，其中
r/10
将返回浮点。还有，为什么要重新计算
r/10
10*len（c）
您可以从get go with
np.arange（）
生成实际阈值的次数？是的，对。但在元组中将清楚使用了什么阈值
np.linspace
可能是一个更好的选择，但不想强加numpy。这两种方法都可以直接为本例生成阈值，不过哪种方法更直接取决于意见。用户明确地使用了numpy，因此没有必要不使用它，但归根结底，这只是一个建议。