如何比较列表中的相应位置？

Question

I have N number of list of same length. How can I compare these lists in corresponding position and output the number of positions where they all match?

For example:

A=[1,0,1,1]
B=[1,1,1,1]
C=[1,0,1,0]

comparison of these three list would output 2 as only position 1 and 3 matches.

I was thinking of converting it into tuple and then zipping it K=zip(A,B,C) , then add each tuple to see if it matches the number of list.

The problem almost sounds like I am missing something that is rather trivial, maybe!

Answer 1

sum(1 if x == y == z else 0 for x, y, z in zip(A, B, C))
2

Answer 2

>>> A = [1, 0, 1, 1]
>>> B = [1, 1, 1, 1]
>>> C = [1, 0, 1, 0]
>>> [len(set(i)) == 1 for i in zip(A,B,C)]
[True, False, True, False]

>>> sum(len(set(i))==1 for i in zip(A,B,C))
2

Answer 3

Using set , as in gnibbler's answer, works for lists containing any kinds of immutable elements -- arbitrary integers, floats, strings, tuples. OP's question doesn't impose any restrictions on what the lists may contain, and assuming only 0 and 1 doesn't simplify anything. The following also works for an arbitrary number of lists, not just 3, which does seem to be part of OP's requirements.

A=[1,0,1,1, 'cat', 4.5,     'no']
B=[1,1,1,1, 'cat', False,   'no']
C=[1,0,1,0, 16,    'John',  'no']
D=[1,0,0,0, (4,3), 'Sally', 'no']


def number_of_matching_positions(*lists):
    """
    Given lists, a list of lists whose members are all of the same length,
    return the number of positions where all items in member lists are equal.
    """
    return sum([len(set(t)) <= 1 for t in zip(* lists)])

print(number_of_matching_positions(),
      number_of_matching_positions(A),
      number_of_matching_positions(A, A),
      number_of_matching_positions(A, B),
      number_of_matching_positions(A, B, C),
      number_of_matching_positions(A, B, C, D))

This will print 0 7 7 5 3 2 .

If the number of lists N can be large, performance can be improved by examining as few elements as possible of each tuple from the zip:

def all_equal(t):
    """Return True if all elements of the sequence t are equal, False otherwise."""
    # Use a generator comprehension,
    # so that 'all' will stop checking t[i] == t[0] 
    # as soon as it's false for some i.
    return (not t) or \
            all( (t[i] == t[0] for i in range(1, len(t))) )

def number_of_matching_positions_alt(*lists):
    # Instead of 'len(set(t)) <= 1', 
    # do less work in case len(lists) alias len(t) can be large
    return sum( [all_equal(t) for t in zip(* lists)] )

Answer 4

If you want to know the positions where all the lists are matching then

list(x for x, (xa, xb, xc) in enumerate(zip(a, b, c))
     if xa == xb == xc)

seems to me the most readable way

If you want to just count the number of columns instead

sum(xa == xb == xc for xa, xb, xc in zip(a, b, c))

works thanks to the fact that in Python True and False can be used in computations as if they were 1 and 0 .