How To Merge Two Lists in Python?

Introduction

Merging two lists in Python is a basic operation that always arises in programming duties. Whether or not you’re coping with information manipulation, algorithm implementation, or every other coding state of affairs, the power to mix the contents of two lists effectively is a useful talent. In Python, this job may be achieved utilizing varied strategies, providing flexibility based mostly on the particular wants of your code.

It’s a bit like bringing collectively two teams of buddies to create one huge gathering – every buddy represents a component within the checklist, and the merging course of is akin to uniting these social circles.

Enroll in our free Python Course right this moment.

Enter:

# Two pattern lists
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']

Output:

[1, 2, 3, 'a', 'b', 'c']

Python Be a part of Two Lists

Utilizing the “+” Operator

To hitch two lists collectively, we generally use the “+” image. This image helps mix all of the gadgets from one checklist with these from one other, making the 2 lists into one.

# Create two lists
list1 = [11,22,33,44,55]
list2 = [66,77,88,99,110 ]

# Use the "+" image to hitch the lists
result_list = list1 + list2

# Print the mixed checklist
print("Mixed checklist utilizing +:", result_list)

Output:

Mixed checklist utilizing +: [11,22,33,44,55,66,77,88,99,110 ]

Time Complexity:
The time complexity is O(n), the place ‘n’ represents the entire variety of parts in each lists. It’s because the “+” operator goes by each ingredient in each lists to hitch them collectively.

Area Complexity:
The house complexity is O(n), the place ‘n’ represents the entire variety of parts in each lists. It’s because a brand new checklist is generated to retailer the merged parts.

Utilizing the lengthen() technique

The lengthen() technique in Python is used to increase an inventory by appending parts from one other iterable (e.g., an inventory, tuple, or every other iterable). Once you use lengthen(), it modifies the unique checklist in-place, including parts from the iterable to the tip of the checklist.

list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Utilizing lengthen() to merge list2 into list1
list1.lengthen(list2)

# Print the merged checklist
print("Merged Record:", list1)

list1 = [1, 2, 3]
list2 = [4, 5, 6]

On this instance, lengthen() is used on list1 to append all parts from list2 to it. After executing this code, list1 will comprise the merged parts of each lists.

Output:

Merged Record: [1, 2, 3, 4, 5, 6]

Time Complexity:

The time complexity of the lengthen() technique in Python is O(n), the place n is the variety of parts within the iterable being added.

Area Complexity:

The house complexity of the lengthen() technique is O(1), i.e., fixed house. The rationale for that is that the lengthen() technique modifies the present checklist in-place with out creating a brand new checklist. Whatever the measurement of the iterable being added, it solely requires a continuing quantity of extra house.

Utilizing the “*” Operator

In Python, the * operator has a number of makes use of, and one among them is for checklist concatenation or repetition. When used with lists, the * operator performs concatenation by combining the weather of two or extra lists into a brand new checklist. For instance, to hitch or concatenate two lists, you should use the + operator, however the * operator gives a concise technique to obtain the identical outcome.

# Initializing lists
fruits1 = ["apple", "banana", "orange"]
fruits2 = ["grape", "watermelon", "kiwi"]

# utilizing * operator to concatenate lists
combined_fruits = [*fruits1, *fruits2]

# Printing concatenated checklist
print("Concatenated checklist utilizing * operator: " + str(combined_fruits))

On this instance, fruits1 and fruits2 are two lists containing completely different fruits. The * operator is used to concatenate the lists, leading to a brand new checklist referred to as combined_fruits.

Output:

Concatenated checklist utilizing * operator: [‘apple’, ‘banana’, ‘orange’, ‘grape’, ‘watermelon’, ‘kiwi’]

Time Complexity:

The time complexity of checklist concatenation utilizing the * operator is O(n + m), the place n and m are the lengths of the 2 lists being concatenated (fruits1 and fruits2 on this case). It’s because every ingredient in each lists must be copied to the brand new checklist.

Area Complexity:

The house complexity is O(n + m) as properly. The brand new checklist (combined_fruits) is created to retailer the concatenated parts of fruits1 and fruits2. The house required is proportional to the sum of the lengths of the 2 lists.

Utilizing the Naive Methodology

The naive technique of merging two lists entails iterating by the weather of 1 checklist and appending every ingredient to the opposite checklist.

# Initializing lists
fruits1 = ["apple", "banana", "orange"]
fruits2 = ["grape", "watermelon", "kiwi"]

# Utilizing naive technique to merge lists
for fruit in fruits2:
    fruits1.append(fruit)

# Printing concatenated checklist
print("Concatenated checklist utilizing naive technique: " + str(fruits1))

On this instance, fruits1 and fruits2 are two lists containing completely different fruits. The naive technique is used to iterate by the weather of fruits2 and append every ingredient to the tip of fruits1. Lastly, the merged checklist is printed.

Output:

Concatenated checklist utilizing naive technique: [‘apple’, ‘banana’, ‘orange’, ‘grape’, ‘watermelon’, ‘kiwi’]

Time Complexity:

The time complexity of the Naive technique for merging two lists is O(m), the place m is the size of the second checklist (fruits2). It’s because the loop iterates by every ingredient in fruits2 and performs a constant-time operation (appending) for every ingredient.

Area Complexity:

The house complexity is O(1), i.e., fixed house. The operation is carried out in-place, modifying the present fruits1 checklist with out creating a brand new checklist. The house required is fixed and doesn’t depend upon the scale of the enter.

Utilizing the Record Comprehension

Within the context of merging two lists utilizing checklist comprehension, the thought is to create a brand new checklist by iterating over every ingredient in each lists and together with these parts within the new checklist.

# Initializing lists
letters1 = ['a', 'b', 'c']
letters2 = ['x', 'y', 'z']

# Utilizing checklist comprehension to concatenate lists
combined_letters = [char for sublist in [letters1, letters2] for char in sublist]

# Printing concatenated checklist
print("Concatenated checklist utilizing checklist comprehension:", combined_letters)

On this instance, letters1 and letters2 are two lists containing letters. The checklist comprehension iterates over every sublist (containing letters1 and letters2) after which iterates over every character in these sublists. The ensuing combined_letters checklist will comprise all of the letters from each authentic lists.

Output:

Concatenated checklist utilizing checklist comprehension: [‘a’, ‘b’, ‘c’, ‘x’, ‘y’, ‘z’]

Time Complexity:

The time complexity of this checklist comprehension for concatenating lists is O(n + m), the place n and m are the lengths of the 2 lists (letters1 and letters2). The checklist comprehension iterates over all parts in each lists to create the brand new checklist.

Area Complexity:

The house complexity is O(n + m) as properly. The brand new checklist (combined_letters) is created to retailer the concatenated parts of letters1 and letters2. The house required is proportional to the sum of the lengths of the 2 enter lists.

Utilizing the scale back() technique

In Python, the scale back() perform is a part of the functools module, and it’s used for cumulative operations on a sequence of parts. The scale back() perform takes a binary perform (a perform that takes two arguments) and a sequence as enter. It applies the perform cumulatively to the gadgets of the sequence from left to proper, lowering the sequence to a single amassed worth.

from functools import scale back

# Initializing lists
numbers1 = [1, 2, 3, 4, 5]
numbers2 = [6, 7, 8, 9, 10]

# Create a nested checklist
nested_numbers = [numbers1, numbers2]

# Use scale back() and lambda perform to concatenate lists
outcome = scale back(lambda x, y: x + y, nested_numbers, [])

# Print the concatenated checklist
print("Concatenated checklist utilizing scale back and lambda:", outcome)

On this instance, the scale back() perform, together with a lambda perform, is used to concatenate two lists. The lambda perform provides the weather of the lists, and scale back() applies it iteratively to a nested checklist, leading to a concatenated checklist. The preliminary worth for accumulation is an empty checklist []. The ultimate result’s printed because the output, showcasing a concise method to checklist concatenation utilizing scale back() and a lambda perform.

Output:

Concatenated checklist utilizing scale back and lambda: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Time Complexity:

The time complexity is O(n + m), the place n and m are the lengths of the 2 lists (numbers1 and numbers2). The scale back() perform iterates over all parts within the nested checklist, and the lambda perform provides every ingredient to the amassed outcome.

Area Complexity:

The house complexity is O(n + m) as properly. The scale back() perform accumulates the outcome by concatenating the lists, and the house required is proportional to the sum of the lengths of the 2 enter lists. The empty checklist [] offered because the preliminary worth doesn’t contribute considerably to the house complexity.

Conclusion

In conclusion, merging two lists in Python gives varied strategies, every with its personal benefits. The + operator gives an easy and concise method, whereas the lengthen() technique effectively appends parts from one checklist to a different. Record comprehension gives a concise technique to merge lists by iterating by their parts. For extra complicated eventualities, the scale back() perform from the functools module proves helpful, albeit with potential reminiscence issues.

Selecting the suitable technique is determined by components comparable to readability, effectivity, and reminiscence utilization. The lengthen() technique and checklist comprehension are typically really helpful for merging giant lists on account of their reminiscence effectivity. Understanding these strategies empowers builders to pick out probably the most appropriate method based mostly on particular necessities.

You can even refer our different articles to be taught and discover about Python checklist:

Often Requested Query

Associated