How to Concatenate Lists in Python

Python lists are versatile and widely used data structures that allow the storage and manipulation of collections of items. One common operation when working with lists is concatenation which involves combining two or more lists to create a new list. This process is particularly useful when merging the data or creating a larger list from smaller ones. List concatenation can be achieved using various methods, and understanding these techniques is fundamental to efficiently work with lists in Python. Whether you are merging lists of numbers, strings, or complex objects, mastering the list concatenation allows you to manipulate and organize the data in diverse ways.

Example 1: Concatenating Lists with “+” Operator

We can use the “+” operator in Python to concatenate the lists. Using the “+” operator, you can join two or more lists to form a new list. When you use the “+” operator with lists, a new list is created and the elements of the original lists are copied to the new list in the order that they appear.

Here’s a simple example:

list1 = [1, 2, 3]

list2 = [4, 5, 6]

result_list = list1 + list2


We have two lists in this illustration: “list1” and “list2”. We use the “+” operator to integrate them into a single list. When used with lists, the “+” operator concatenates them which means that it joins the elements of the second list to the end of the first one. So, after executing the “result_list = list1 + list2″, the “result_list” will contain the elements of both “list1” and “list2” in the order in which they were concatenated.

While this method is concise, keep in mind that it creates a new list which may not be efficient for large lists due to the overhead of creating a copy.

Example 2: Utilizing the Extend() Method

The items of an iterable can be appended to the end of an existing list using the extend() method. It modifies the original list in place, unlike the “+” operator which creates a new list.

Let’s suppose we have a list of students in a class, and we want to extend this list by adding the names of new students who recently joined using the extend() method. Here’s how you might go about it:

class_students = ['Alice', 'Bella', 'Charlie']

new_students = ['David', 'Eva', 'Adam']


print("Updated List of Students:", class_students)

In this example, the original list which is “class_students” contains the names of existing students. The “new_students” list includes the names of students who recently joined the class. By applying the extend() method, we add the names of the new students to the end of the original list.

Example 3: Applying the “+=” Operator for Concatenation

The “+=” operator is a shorthand for the extend() method. It modifies the list in place, combining the elements of the right-hand list into the left-hand list.

Suppose we have a list of favorite colors and we want to update it by adding more colors using the “+=” operator.

favorite_colors = ['blue', 'green', 'red']

additional_colors = ['purple', 'orange', 'yellow']

favorite_colors += additional_colors

print("Updated Favorite Colors:", favorite_colors)

In this scenario, we start with a list of our favorite colors which is represented by “favorite_colors”. Then, we have some new colors that we’d like to include in the “additional_colors” list. Using the “+= operator”, we combine the new colors with our existing favorites, modifying the “favorite_colors” list.

After the operation, when we print “Our Updated Favorite Colors”, we can see the following result:

Example 4: Using the “*” Operator

The “*” operator can be used for list replication. But when applied to lists, it can concatenate them by repeating the elements.

Here’s an example:

original_list = [1, 2, 3]

concatenated_list = original_list * 3


In this case, we start with an “original_list” that contains the elements [1, 2, 3]. Using the “*” operator, we create a new list which is the “concatenated_list” that consists of three repetitions of the elements from the original list.

While this approach is less common for concatenation, it showcases the flexibility of Python’s operators.

Example 5: Applying the Itertools.chain() Function

The itertools.chain() function is part of the “itertools” module and is used to concatenate the iterable (like lists, tuples, or other iterable objects) into a single “iterable”. Unlike some other concatenation methods, itertools.chain() does not create a new list but produces an iterator over the elements of the input iterables.

from itertools import chain

L1 = [1, 2, 3]

L2 = ['x', 'y', 'z']

concatenated_iterable = chain(L1, L2)

result_list = list(concatenated_iterable)


In the given example, we have two lists – “L1” contains the numerical values [1, 2, 3] and “L2” contains the alphabetic characters [“x”, “y”, “z”]. Using the itertools.chain() function, we concatenate these lists into a single iterable, represented by “concatenated_iterable”. The list() function is then applied to convert the iterable into a list which results in the combined list [1, 2, 3, “x”, “y”, “z”].

Example 6: List Slicing

By providing a range of indices, list slicing is a technique that lets us retrieve a subset of a list. It involves using the colon (:) operator within the square brackets to indicate the start, stop, and, optionally, step values.

Here is the example code:

actual_list = [1, 2, 3, 4, 5]

sliced_list = actual_list[1:4]


We begin the illustration with an original list of numbers which is denoted as “actual_list” that contains the elements [1, 2, 3, 4, 5]. We extract a specific segment of the list by employing the list slicing which is a powerful feature in Python. The “actual_list[1:4]” slice is used in this instance, and it picks the elements from index 1 to index 3 (but not from index 4). The result is a new list, named “sliced_list”, that contains the sliced portion [2, 3, 4].

Example 7: Concatenation with the Zip() Function

The zip() function combines the elements from multiple iterables, creating pairs or tuples of corresponding elements. Each iteration’s elements at the same index are used to create these pairs.

students = ['Alice', 'Bob', 'Charlie']

grades = [85, 92, 78]

student_grade_pairs = zip(students, grades)

result_dict = dict(student_grade_pairs)

print("Student-Grade Pairs:", result_dict)

In this example, the zip() function pairs the student names from the “students” list with their corresponding grades from the “grades” list which results in a dictionary where each student is associated with their respective grade.


In conclusion, Python offers a multitude of ways to concatenate the lists, each with its advantages. As we explored the various methods, from the straightforward “+” operator to the more nuanced zip() function, it became evident that Python caters to diverse programming styles and preferences. Depending on the work at hand, factors like readability, memory efficiency, and the type of data being processed will determine which method is best.

About the author

Omar Farooq

Hello Readers, I am Omar and I have been writing technical articles from last decade. You can check out my writing pieces.