Python: find sequential change in one member of list pairs, report other

Question

There must be a simpler, more pythonic way of doing this.

Given this list of pairs:

pp = [('a',1),('b',1),('c',1),('d',2),('e',2)]

How do I most easily find the first item in adjacent pairs where the second item changes (here, from 1 to 2). Thus I'm looking for ['c','d']. Assume there will only be one change in pair[1] for the entire list, but that it may be a string.

This code works but seems excruciatingly long and cumbersome.

for i, pair in enumerate(pp):
    if i == 0: 
        pInitial = pair[0] 
        sgInitial = pair[1]
    pNext = pair[0]
    sgNext = pair[1]
    if sgInitial == sgNext:
        sgInitial = sgNext
        pInitial = pNext
    else:
        pOne = pInitial
        pTwo = pNext
        x = [pOne, pTwo]
        print x
        break

Thanks Tim

Tony Veijalainen · Accepted Answer · 2010-08-31T14:32:40.483

2

import itertools as it

pp = [('a',1),('b',1),('c',1),('d',2),('e',2)]

# with normal zip and slicing
for a,b in zip(pp,pp[1:]):
    if a[1] != b[1]:
        x=(a[0],b[0])
        print x
        break
# with generators and izip
iterfirst = (b for a,b in pp)
itersecond = (b for a,b in pp[1:])
iterfirstsymbol = (a for a,b in pp)
itersecondsymbol = (a for a,b in pp[1:])
iteranswer = it.izip(iterfirstsymbol, itersecondsymbol, iterfirst, itersecond)

print next((symbol1, symbol2)
           for symbol1,symbol2, first, second in iteranswer
           if first != second)

Added my readable generator version.

edited Aug 31 '10 at 14:32

answered Aug 30 '10 at 15:52

Tony Veijalainen

5,447
23
31

I like the way you treat the list as two lists, the second simply starting at the second tuple. Thanks! – Tim Aug 31 '10 at 11:59
Check out also my answer on other thread: http://stackoverflow.com/questions/3460161/remove-adjacent-duplicate-elements-from-a-list/3463143#3463143 See the similarity? – Tony Veijalainen Aug 31 '10 at 13:02

score 0 · Answer 2 · answered Aug 30 '10 at 15:48

0

You could try somethingl like :

[[pp[i][0],pp[i+1][0]] for i in xrange(len(pp)-1) if pp[i][1]!=pp[i+1][1]][0]

(using list comprehension)

answered Aug 30 '10 at 15:48

ThR37

3,965
6
35
42

Thank you, list comprehensions looks like a good way to go as well. – Tim Aug 31 '10 at 11:59

score 0 · Answer 3 · answered Aug 30 '10 at 15:49

try comparing pp[:-1] to pp[1:], something like

[a for a in zip(pp[:-1], pp[1:]) if a[0][1] != a[1][1]]

(look at zip(pp[:-1], pp[1:]) first to see what's going on

edit:

i guess you'd need

([a[0][0], a[1][0]] for a in zip(pp[:-1], pp[1:]) if a[0][1] != a[1][1]).next()

score 0 · Answer 4 · answered Aug 30 '10 at 16:19

0

>>> import itertools
>>> pp = [('a',1),('b',1),('c',1),('d',2),('e',2)]
>>> gb = itertools.groupby(pp, key=lambda x: x[1])
>>> f = lambda x: list(next(gb)[1])[x][0]
>>> f(-1), f(0)
('c', 'd')

answered Aug 30 '10 at 16:19

SilentGhost

307,395
66
306
293

score 0 · Answer 5 · answered Aug 30 '10 at 19:30

Here is something (simple?) with recursion:

def first_diff( seq, key=lambda x:x ):
    """ returns the first items a,b of `seq` with `key(a) != key(b)` """
    it = iter(seq)
    def test(last): # recursive function
        cur = next(it)
        if key(last) != key(cur):
            return last, cur
        else:
            return test(cur)
    return test(next(it))

print first_diff( pp, key=lambda x:x[1]) # (('c', 1), ('d', 2))

score 0 · Answer 6 · answered Aug 30 '10 at 19:40

0

pp = [('a',1),('b',1),('c',1),('d',2),('e',2)]
def find_first(pp):
    for i,(a,b) in enumerate(pp):
        if i == 0: oldb = b
        else:
            if b != oldb: return i
    return None
print find_first(pp)

answered Aug 30 '10 at 19:40

amwinter

3,121
2
27
25

score 0 · Answer 7 · answered Oct 12 '11 at 01:51

>>> pp = [('a',1),('b',1),('c',1),('d',2),('e',2)]
>>> [[t1, t2] for ((t1, v1), (t2, v2)) in zip(pp, pp[1:]) if v1 != v2] [0]
['c', 'd']
>>>

I like this for clarity...if you find list comprehensions clear. It does create two temporary lists: pp[1:] and the zip() result. Then it compares all the adjacent pairs and gives you the first change it found.

This similar-looking generator expression doesn't create temporary lists and stops processing when it reaches the first change:

>>> from itertools import islice, izip
>>> ([t1, t2] for ((t1, v1), (t2, v2)) in izip(pp, islice(pp, 1, None)) 
...           if v1 != v2
... ).next()
['c', 'd']
>>>

Everybody's examples on this page are more compact than they would be if you wanted to catch errors.

Python: find sequential change in one member of list pairs, report other

7 Answers7

Linked