Python – Sorting/grouping odd and even numbers in odd and even segregated list

pythonsorting

I have a unsorted list of number with even and odd. I need to segregate odd and even numbers in sorted order.

For example:

List = [5,6,4,7,11,14,12,1,3]

Expected output :

[4,6,12,14,1,3,5,7,11]

My program to segregate the odd and even numbers.

L = [5,6,4,7,11,14,12,1,3]
def segregateEvenOdd(L):
    left,right = 0,len(L)-1
    while left < right:
        while (L[left]%2==0 and left < right):
            left += 1
        while (L[right]%2 == 1 and left < right):
            right -= 1
        if (left < right):
            L[left],L[right] = L[right],L[left]
            left += 1
            right = right-1

print segregateEvenOdd(L)

output : [12, 6, 4, 14, 11, 7, 5, 1, 3]

I am trying to sort the list using insertion sort, couldn't get right output. Any way to sort this easily

Best Answer

Using a "smart" key function for list.sort / sorted:

>>> list(sorted(lst, key=lambda x: [x % 2, x]))
[4, 6, 12, 14, 1, 3, 5, 7, 11]

maps even numbers to the value [0, n], and odd numbers to the value [1, n], so that even numbers come first according to natural ordering.

Related Solutions

Python – the difference between Python’s list methods append and extend

append: Appends object at the end.

x = [1, 2, 3]
x.append([4, 5])
print(x)

gives you: [1, 2, 3, [4, 5]]

extend: Extends list by appending elements from the iterable.

x = [1, 2, 3]
x.extend([4, 5])
print(x)

gives you: [1, 2, 3, 4, 5]

Python – List changes unexpectedly after assignment. Why is this and how can I prevent it

With new_list = my_list, you don't actually have two lists. The assignment just copies the reference to the list, not the actual list, so both new_list and my_list refer to the same list after the assignment.

To actually copy the list, you have various possibilities:

You can use the builtin list.copy() method (available since Python 3.3):
```
new_list = old_list.copy()
```
You can slice it:
```
new_list = old_list[:]
```
Alex Martelli's opinion (at least back in 2007) about this is, that it is a weird syntax and it does not make sense to use it ever. ;) (In his opinion, the next one is more readable).
You can use the built in list() function:
```
new_list = list(old_list)
```
You can use generic copy.copy():
```
import copy
new_list = copy.copy(old_list)
```
This is a little slower than list() because it has to find out the datatype of old_list first.
If the list contains objects and you want to copy them as well, use generic copy.deepcopy():
```
import copy
new_list = copy.deepcopy(old_list)
```
Obviously the slowest and most memory-needing method, but sometimes unavoidable.

Example:

import copy

class Foo(object):
    def __init__(self, val):
         self.val = val

    def __repr__(self):
        return 'Foo({!r})'.format(self.val)

foo = Foo(1)

a = ['foo', foo]
b = a.copy()
c = a[:]
d = list(a)
e = copy.copy(a)
f = copy.deepcopy(a)

# edit orignal list and instance 
a.append('baz')
foo.val = 5

print('original: %r\nlist.copy(): %r\nslice: %r\nlist(): %r\ncopy: %r\ndeepcopy: %r'
      % (a, b, c, d, e, f))

Result:

original: ['foo', Foo(5), 'baz']
list.copy(): ['foo', Foo(5)]
slice: ['foo', Foo(5)]
list(): ['foo', Foo(5)]
copy: ['foo', Foo(5)]
deepcopy: ['foo', Foo(1)]

Best Answer

Related Solutions

Python – the difference between Python’s list methods append and extend

Python – List changes unexpectedly after assignment. Why is this and how can I prevent it

Related Topic