# 5 Best Ways to Combine Two Lists in Python While Maintaining Duplicates in the First List

Rate this post
5 Best Ways to Combine Two Lists in Python While Maintaining Duplicates in the First List

π‘ Problem Formulation: When working with lists in Python, a common task is to merge two lists together while preserving the order and duplicates of the first list. Specifically, we may want to append the elements of the second list to the first, but only the elements that are not already present. For example, given the lists `list1 = [1, 2, 2, 3]` and `list2 = [3, 4, 2, 4]`, we want to combine them to get `[1, 2, 2, 3, 4]`.

## Method 1: Use a for Loop with Conditional Check

In this method, we iterate through the second list and append each element to the first list only if it is not already present in it. This approach is straightforward and easy to understand but may not be the most efficient for large lists due to its O(nΒ²) complexity in the worst case.

Here’s an example:

```list1 = [1, 2, 2, 3]
list2 = [3, 4, 2, 4]
for elem in list2:
if elem not in list1:
list1.append(elem)
print(list1)```

The output of this code snippet will be:

`[1, 2, 2, 3, 4]`

This code starts a loop that goes through each element in `list2` and checks if it’s not in `list1`. If the element is not present, it’s appended to `list1`. We end up with a combined list including duplicates from the first list but only unique new elements from the second list.

## Method 2: Using Sets for Improved Efficiency

Sets in Python allow us to improve the efficiency of the combining process by taking advantage of the fact that they automatically remove duplicates. First, we convert the first list to a set, then add elements of the second list to this set, and finally, convert it back to a list. Note that this method does not preserve the order of elements.

Here’s an example:

```list1 = [1, 2, 2, 3]
list2 = [3, 4, 2, 4]
combined_list = list(set(list1).union(list2))
print(combined_list)```

The output of this code snippet may vary, but one possible output could be:

`[1, 2, 3, 4]`

This code snippet creates a set from `list1`, which removes duplicates, then uses the `union()` method to combine it with `list2`. Finally, it converts the set back to a list. However, because sets are unordered, the original order from `list1` is not preserved.

## Method 3: List Comprehension with a Conditional Check

A more Pythonic way of combining two lists while maintaining the duplicates in the first list is to use list comprehension. This method is concise and easy to read and tends to be more efficient than method 1 due to the optimized nature of list comprehensions in Python.

Here’s an example:

```list1 = [1, 2, 2, 3]
list2 = [3, 4, 2, 4]
list1 += [elem for elem in list2 if elem not in list1]
print(list1)```

The output of this code snippet will be:

`[1, 2, 2, 3, 4]`

In this code, we use a list comprehension to create a new list with elements from `list2` that are not already in `list1` and extend `list1` with this new list. It’s a clean and efficient one-liner solution.

## Method 4: Using itertools.chain

The itertools module provides a function `chain()`, which can be used to combine multiple iterables. Once combined, we can again use a list comprehension or similar approach to filter out duplicates. This method can be efficient, especially when dealing with very large lists or multiple lists.

Here’s an example:

```import itertools
list1 = [1, 2, 2, 3]
list2 = [3, 4, 2, 4]
combined_iterable = itertools.chain(list1, (elem for elem in list2 if elem not in list1))
combined_list = list(combined_iterable)
print(combined_list)```

The output of this code snippet will be:

`[1, 2, 2, 3, 4]`

This code snippet uses `itertools.chain()` to concatenate `list1` with a generator expression that includes only those elements from `list2` not already in `list1`. The result is a combined list that maintains `list1`‘s duplicates and order.

## Bonus One-Liner Method 5: Using “+=” Operator and a Filter

The “+=” operator can be used in conjunction with a filter function to append only non-duplicate elements from the second list to the first. This one-liner approach is intuitive and concise, although it may suffer from the same potential inefficiency as the loop method with large lists.

Here’s an example:

```list1 = [1, 2, 2, 3]
list2 = [3, 4, 2, 4]
list1 += filter(lambda x: x not in list1, list2)
print(list1)```

The output of this code snippet will be:

`[1, 2, 2, 3, 4]`

This compact solution filters out elements from `list2` that are already in `list1` using a lambda function and extends `list1` by using the `+=` operator.

## Summary/Discussion

• Method 1: For Loop with Conditional Check. Simple and easy to implement. Not suitable for large lists due to poor efficiency.
• Method 2: Using Sets for Improved Efficiency. Efficient in terms of computation time but does not preserve order or duplicates from the first list.
• Method 3: List Comprehension with Conditional Check. Clean, concise, and relatively efficient. Preserves order and duplicates from the first list.
• Method 4: Using itertools.chain. Efficient for very large or multiple lists. Preserves order and duplicates from the first list.
• Bonus Method 5: Using “+=” Operator and Filter. Intuitive and simple one-liner, but may not be the most efficient for large data sets.