Python：按数量级对列表进行分类

Question

I have a nested list with values:

list = [
...
['Country1', 142.8576737907048, 207.69725105029553, 21.613192419863577, 15.129178465784218],
['Country2', 109.33326343550823, 155.6847323746669, 15.450489646386226, 14.131554442715336],
['Country3', 99.23033109735835, 115.37122637190915, 5.380298424850267, 5.422030104456135],
...]

I want to count values in the second index / column by order of magnitude, starting at the lowest order of magnitude and ending at the largest...eg

99.23033109735835 = 10 <= x < 100
142.8576737907048 = 100 <= x < 1000
             9432 = 1000 <= x < 10000

The aim is to output a simple char (#) count for how many index values fall in each category, eg

  10 <= x < 100: ###
100 <= x < 1000: #########

I've started by grabbing the max() and min() values for the index in order to automatically calculate the largest and smalles magnitude categories, but I'm not sure how to associate each value in the column to an order of magnitude...if someone could point me in the right direction or give me some ideas I would be most grateful.

Answer 1

This function will turn your double into an integer order of magnitude:

>>> def magnitude(x):
...     return int(math.log10(x))
... 
>>> magnitude(99.23)
1
>>> magnitude(9432)
3

(so 10 ** magnitude(x) <= x <= 10 ** (1 + magnitude(x)) for all x ).

Just use the magnitude as a key, and count the occurrences per key. defaultdict may be helpful here.

---

Note this magnitude only works for positive powers of 10 (because int(double) truncation rounds towards zero).

Use

def magnitude(x):
    return int(math.floor(math.log10(x)))

instead if this matters for your use case. (Thanks to larsmans for pointing this out).

Answer 2

Extending Useless ' answer to all real numbers, you can use:

import math

def magnitude (value):
    if (value == 0): return 0
    return int(math.floor(math.log10(abs(value))))

Test cases:

In [123]: magnitude(0)
Out[123]: 0

In [124]: magnitude(0.1)
Out[124]: -1

In [125]: magnitude(0.02)
Out[125]: -2

In [126]: magnitude(150)
Out[126]: 2

In [127]: magnitude(-5280)
Out[127]: 3

Answer 3

If x is one of your numbers, what is len(str(int(x))) ?

Or, if you have numbers less than 0, what is int(math.log10(x)) ?

(See also log10 's docs. Also note that int() rounding here may not be what you want - see ceil and floor , and note you may need int(ceil(...)) or int(floor(...)) to get an integer answer)

Answer 4

To categorize by the order of magnitude do:

from math import floor, log10
from collections import Counter
counter =  Counter(int(floor(log10(x[1]))) for x in list)

1 is from 10 to less then 100, 2 from 100 to less then 1000.

print counter
Counter({2: 2, 1: 1})

Then its just simply printing it out

for x in sorted(counter.keys()):
    print "%d <= x < %d: %d" % (10**x, 10**(x+1), counter[x])

Answer 5

import bisect
from collections import defaultdict
lis1 = [['Country1', 142.8576737907048, 207.69725105029553, 21.613192419863577, 15.129178465784218],
['Country2', 109.33326343550823, 155.6847323746669, 15.450489646386226, 14.131554442715336],
['Country3', 99.23033109735835, 115.37122637190915, 5.380298424850267, 5.422030104456135],
]
lis2 = [0, 100, 1000, 1000]

dic = defaultdict(int)

for x in lis1:
       x = x[1]
       ind=bisect.bisect(lis2,x) 
       if not (x >= lis2[-1] or x <= lis2[0]):
           sm, bi = lis2[ind-1], lis2[ind]
           dic ["{} <= {} <= {}".format(sm ,x, bi)] +=1
for k,v in dic.items():
    print k,'-->',v

output:

0 <= 99.2303310974 <= 100 --> 1
100 <= 142.857673791 <= 1000 --> 1
100 <= 109.333263436 <= 1000 --> 1

Answer 6

In case you ever want overlapping ranges or ranges with arbitrary bounds (not sticked to orders of magnitude/powers of 2/any other predictable series):

from collections import defaultdict
lst = [
    ['Country1', 142.8576737907048, 207.69725105029553, 21.613192419863577, 15.129178465784218],
    ['Country2', 109.33326343550823, 155.6847323746669, 15.450489646386226, 14.131554442715336],
    ['Country3', 99.23033109735835, 115.37122637190915, 5.380298424850267, 5.422030104456135],
]

buckets = {
    '10<=x<100': lambda x: 10<=x<100,
    '100<=x<1000': lambda x: 100<=x<1000,
}

result = defaultdict(int)
for item in lst:
    second_column = item[1]
    for label, range_check in buckets.items():
        if range_check(second_column):
            result[label] +=1

print (result)

Answer 7

Another option, using bisect

import bisect
from collections import Counter
list0 = [
['Country1', 142.8576737907048, 207.69725105029553, 21.613192419863577, 15.129178465784218],
['Country2', 109.33326343550823, 155.6847323746669, 15.450489646386226, 14.131554442715336],
['Country3', 99.23033109735835, 115.37122637190915, 5.380298424850267, 5.422030104456135]
]

magnitudes = [10**x for x in xrange(5)]
c = Counter(bisect.bisect(magnitudes, x[1]) for x in list0)
for x in c:
  print x, '#'*c[x]