将值附加和分配给列表有什么区别？

Question

When I use one-line-for loop in Python, I will got two different values depending on the process I choose(Assign and append processes). I want to understand the difference and how they work. In the following two examples, I trying to write a program that returns a list that contains only the elements that are common between the lists (without duplicates).

First program with append and I get the right result:

a = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
b = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

def common_in_two_lists(list1, list2):
   re_list = []
   [re_list.append(val1) for val1 in list1 for val2 in list2 if val1==val2 and val1 not in re_list]
   return re_list

After call the function and print output list:

l = common_in_two_lists(a, b)
print(l)

and the output is:

[1, 2, 3, 5, 8, 13]

But when I use assign way as the following I will got the wrong answer:

def common_in_two_lists(list1, list2):
   re_list = []
   re_list = [val1 for val1 in list1 for val2 in list2 if val1==val2 and val1 not in re_list]
   return re_list

l = common_in_two_lists(a, b)
print(l)

and the output is:

[1, 1, 2, 3, 5, 8, 13]

Anyone can learn me to understand How do this two different way work?

Answer 1

You need to break down the code into simpler form to understand it. Taking the first example.

a = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
b = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]


def common_in_two_lists1(list1, list2):
    re_list = []
    for val1 in list1:
        for val2 in list2:
            if val1 == val2 and val1 not in re_list:
                re_list.append(val1)
                print(re_list)
    return re_list


l = common_in_two_lists1(a, b)

OUTPUT

[1]
[1, 2]
[1, 2, 3]
[1, 2, 3, 5]
[1, 2, 3, 5, 8]
[1, 2, 3, 5, 8, 13]

You can see that the re_list is appending the value every time. And the [] you have put for the first example is useless.

Coming to your second example. If you check the type of the expression, you would find it to be generator.

re_list = print(type(val1 for val1 in list1 for val2 in list2 if val1 == val2 and val1 not in re_list))
<class 'generator'>

And generator expression is evaluated only when you are try to fetch the value, that explains why you are getting the duplicate 1 on this code. Because in the expression re_list is empty when the generator is created.

Finally coming to your solution:

I trying to write a program that returns a list that contains only the elements that are common between the lists (without duplicates).

You should follow Jon Clements♦ advice and implement it using a set

you should take a look at sets... eg: list(set(a).intersection(b))

Answer 2

In your second example re_list is empty by the time new list is created, so val1 not in re_list is always false. In the first one you create a list of what is returned by re_list.append() ( None , as I remember) and assign it to nowhere while modifying re_list .

By the way, why don't you use set() to obtain a list of unique elements?

Answer 3

def common_in_two_lists(list1, list2):
   re_list = []
   [re_list.append(val1) for val1 in list1 for val2 in list2 if val1==val2 and val1 not in re_list]
   return re_list

is equivalent to:

def common_in_two_lists(list1, list2):
   re_list = []
   for val1 in list1:
       for val2 in list2:
          if val1==val2 and val1 not in re_list:
             re_list.append(val1)
   return re_list

while the second method:

def common_in_two_lists(list1, list2):
   re_list = []
   re_list = [val1 for val1 in list1 for val2 in list2 if val1==val2 and val1 not in re_list]
   return re_list

is equivalent to

def common_in_two_lists(list1, list2):
    re_list_old = []
    re_list = []
    for val1 in list1:
        for val2 in list2:
            if val1==val2 and val1 not in re_list_old: #note re_list_old here
                re_list.append(val1)
    return re_list

It is worth to notice that with the second method you are not checking for duplicates in the final list because everytime you check the empty list while doing val1 not in re_list

Both ways work in O(n**2) time complexity, using sets :

l = list(set(a) & set(b))

it's more efficient and simpler as you can do it with average time complexity O(min(len(a), len(b)) (the worst case is O(len(a)*len(b)) ).