CODEWITHSUNDEEP
python
John
John

Reputation: 41

Getting every odd variable in a list?

If I make a list in Python and want to write a function that would return only odd numbers from a range 1 to x how would I do that?

For example, if I have list [1, 2, 3, 4] from 1 to 4 (4 ix my x), I want to return [1, 3].

Upvotes: 4

Views: 13490

Answers (3)

Jim Dennis
Jim Dennis

Reputation: 17510

What's wrong with:

def getodds(lst):
    return lst[1::2]

....???

(Assuming you want every other element from some arbitrary sequence ... all those which have odd indexes).

Alternatively if you want all items from a list of numbers where the value of that element is odd:

def oddonly(lst):
    return [x for x in lst if x % 2]

[Update: 2017]

You could use "lazy evaluation" to yield these from generators:

def get_elements_at_odd_indices(sequence):
    for index, item in enumerate(sequence):
        if index % 2:
            yield item
        else:
            continue

For getting odd elements (rather than elements at each odd offset from the start of the sequence) you could use the even simpler:

def get_odd_elements(sequence):
    for item in sequence:
        if item % 2:
            yield item
        else:
            continue

This should work for any sequence or iterable object types. (Obviously the latter only works for those sequences or iterables which yield numbers ... or other types for which % 2 evaluates to a meaningfully "odd" result).

Also note that, if we want to efficiently operate on Pandas series or dataframe columns, or the underlying NumPy then we could get the elements at odd indexes using the [1::2] slice notation, and we can get each of the elements containing odd values using NumPy's "fancy indexing"

For example:

import numpy as nd
arr = nd.arange(1000)
odds = arr[arr%2!=0]

I show the "fancy index" as arr[arr%2!=0] because that will generalize better to filtering out every third, fourth or other nth element; but you can use much more elaborate expressions.

Note that the syntax arr[arr%2!=0] may look a bit odd. It's magic in the way that NumPy over-rides various arithmetic and bitwise operators and augmented assignment operations. The point is that NumPy evaluates such operations into machine code which can be efficiently vectorized over NumPy arrays ... using SIMD wherever the underlying CPU supports. For example on typical laptop and desktop systems today NumPy can evaluate many arithmetic operations into SSE operations.

Upvotes: 3

tzot
tzot

Reputation: 96011

To have a range of odd/even numbers up to and possibly including a number n, you can:

def odd_numbers(n):
    return range(1, n+1, 2)
def even_numbers(n):
    return range(0, n+1, 2)

If you want a generic algorithm that will take the items with odd indexes from a sequence, you can do the following:

import itertools
def odd_indexes(sequence):
    return itertools.islice(sequence, 1, None, 2)
def even_indexes(sequence):
    return itertools.islice(sequence, 0, None, 2)

Upvotes: 0

Alex Martelli
Alex Martelli

Reputation: 882351

If you want to start with an arbitrary list:

[item for item in yourlist if item % 2]

but if you're always starting with range, range(1, x, 2) is better!-)

For example:

$ python -mtimeit -s'x=99' 'filter(lambda(t): t % 2 == 1, range(1, x))'
10000 loops, best of 3: 38.5 usec per loop
$ python -mtimeit -s'x=99' 'range(1, x, 2)'
1000000 loops, best of 3: 1.38 usec per loop

so the right approach is about 28 times (!) faster than a somewhat-typical wrong one, in this case.

The "more general than you need if that's all you need" solution:

$ python -mtimeit -s'yourlist=range(1,99)' '[item for item in yourlist if item % 2]'
10000 loops, best of 3: 21.6 usec per loop

is only about twice as fast as the sample wrong one, but still over 15 times slower than the "just right" one!-)

Upvotes: 14

Related Questions