Python“R Cut”函数

Question

I am wondering if there is a function in Python already written for the goal that I describe later. If not, what would be the easiest way to implement. My code is attached.

Say I have a range from 1 to 999999999. Given a list of numbers like this:

[9, 44, 99]

It would return

[(1,9), (10,44), (45,99), (100, 999999999)]

If the number which are the limits are included in the input numbers, it should handle that also. Say input is

[1, 9, 44, 999999999]

The return should be:

[(1,9), (10,44), (45, 999999999)]

I could write a for loop comparing with a few conditional statement but wondering if there is a more 'smart way'.

Some data massage that might be helpful:

points = [1, 9, 44, 99]
points = sorted(list(set(points + [1, 999999999])))

UPDATED INFO: FINAL CREDITS GIVEN TO alecxe, thanks for your inspiring list comprehension solution

l = sorted(list(set(points + [1, 999999999])))
[(l[i] + int(i != 0), l[i + 1]) for i in xrange(len(l) - 1)]

You can put all that in one line but I think that is unnessary.

Answer 1

pandas.cut()

Example

[1,2,3,4,5,6,7,8,9,10] ---> [A,A,B,B,C,C,D,D,E,E]

R:

x  <- seq(1,10,1)
cut(x, breaks = seq(0,10,2), labels = c('A','B','C','D','E'))

Python:

import pandas
x = range(1, 11, 1)
pandas.cut(x, bins=range(0, 12, 2), labels=['A','B','C','D','E'])

Answer 2

def myCut(low, high, points):
    answer = []
    curr = low
    for point in points:
        answer.append((curr, point))
        curr = point + 1
    answer.append((curr, high))
    return answer

>>> low = 1
>>> high = 999999999
>>> points = [9, 44, 109]
>>> myCut(low, high, points)
[(1, 9), (10, 44), (45, 109), (110, 999999999)]

Inspired by this answer and the discussions that followed, here's a solution in fewer lines, with itertools . This uses itertools.chain and itertools.izip (in python2.7; zip in python3.x) to reduce the time and space complexities arising from adding lists, sorting and setifying. Note that the solution assumes that the input list is already sorted, failing which, erroneous results will be produced

cuts = [(i+1, j) for i,j in itertools.izip(itertools.chain([0], myList), itertools.chain(myList, [999999999]))]

>>> import itertools
>>> myList = [9, 44, 99]
>>> [(i+1, j) for i,j in itertools.izip(itertools.chain([0], myList), itertools.
chain(myList, [999999999]))]
[(1, 9), (10, 44), (45, 99), (100, 999999999)]

Answer 3

Not sure this approach is the best one:

>>> l = [1, 9, 44, 999999999]
>>> [(l[i] + int(i != 0), l[i + 1]) for i in xrange(len(l) - 1)]
[(1, 9), (10, 44), (45, 999999999)]

If you are on python 3, replace xrange with range .

Note, that for your first example to work, you'll need to prepend and append your boundaries:

>>> l = [9, 44, 109]
>>> low, high = 1, 999999999
>>> l = [low] + l + [high]
>>> [(l[i] + int(i != 0), l[i + 1]) for i in xrange(len(l) - 1)]
[(1, 9), (10, 44), (45, 109), (110, 999999999)]

Answer 4

Comparing the code from the answers with timeit, it looks like inspectorG4dget's solution performs way better (especially with Python 3) even though I left out the addition of the low and high value in the list comprehension solution:

ls = [9, 44, 109, 200, 567, 894, 6879, 29823]

def f1(low, high, points):
    answer = []
    curr = low
    for point in points:
        answer.append((curr, point))
        curr = point + 1
    answer.append((curr, high))
    return answer

def f2(low, high, l):
    a = [(l[i] + int(i != 0), l[i + 1]) for i in range(len(l) - 1)]
    return a

if __name__ == '__main__':
    import timeit

    print(timeit.timeit("f1(1, 99999999, ls)", setup="from __main__ import f1, ls"))
    print(timeit.timeit("f2(1, 99999999, ls)", setup="from __main__ import f2, ls"))

Results (py3 on my netbook):

3.2064807919996383
8.850830605999363