How to add lists in python

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

Example 1: Concatenating lists with the “+” operator

We can use the “+” operator in Python to combine lists. Using the “+” operator, you can combine two or more lists to create 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 they appear.

Here is a simple example:

sheet 1 , [1, 2, 3]

list2 , [4, 5, 6]

result_list , list1 + list2


In this illustration we have two lists: “List1” and “List2”. We use the “+” operator to unify them into one list. When used with lists, the “+” operator concatenates them meaning it adds the elements of the second list to the end of the first list. So, after executing “result_list = list1 + list2″, “result_list” will contain the elements of both “list1” and “list2” in the same order in which they were combined.

Although 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 copying.

Example 2: Using the extend() method

An iterable item can be added to the end of an existing list using the extend() method. This modifies the original list, unlike the “+” operator, which creates a new list.

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 have recently joined using the extend() method. Here's how you can think about it:

class_student , [‘Alice’, ‘Bella’, ‘Charlie’]

new students , [‘David’, ‘Eva’, ‘Adam’]

Class_Student.Increase,new students,

printing,“Updated list of students:”, class_student,

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

Example 3: Applying the “+=” operator to concatenation

The “+=” operator is short for the extend() method. It modifies a list by combining the elements of the list on the right into the list on the left.

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

favourite colour , [‘blue’, ‘green’, ‘red’]

extra_color , [‘purple’, ‘orange’, ‘yellow’]

favorite_color+, extra_color

printing,“UPDATE FAVORITE COLOR:”, favourite colour,

In this scenario, we start with a list of our favorite colors denoted by “favorite_colors”. Then, we have some new colors that we would like to include in the “additional_colors” list. Using the “+= operator”, we add new colors to our existing favorites, modifying the “favorites_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 combine elements by repeating them.

Here's an example:

original_list , [1, 2, 3]

combined_list , original_list* 3


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

Although this approach is less common for concatenation, it demonstrates the flexibility of Python's operators.

Example 5: Implementing Itertools.chain() Function

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

From itertools Import Chain

L1 , [1, 2, 3]

L2 , [‘x’, ‘y’, ‘z’]

combined_iterative , Chain,L1, L2,

result_list , List,combined_iterative,


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

Example 6: List Slicing

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

Here is example code:

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

chopped_list , actual_list[1:4]


We start the illustration with a basic list of numbers denoted as “real_list” consisting of the elements [1, 2, 3, 4, 5], We extract a specific section of the list using list slicing which is a powerful feature in Python. “actual_list.”[1:4]In this example slices are used, and it selects elements from index 1 to index 3 (but not from index 4). The result is a new list, named “sliced_list”, containing the sliced ​​part. [2, 3, 4],

Example 7: Combination with zip() function

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

Student , [‘Alice’, ‘Bob’, ‘Charlie’]

grade , [85, 92, 78]

student_grade_pairs , zip,Student, grade,

result_instructions , Order,student_grade_pairs,

printing,“Student-grade pairs:”, result_instructions,

In this example, the zip() function combines the names of students from the “Students” list with their respective grades from the “Grades” list resulting in a dictionary where each student is associated with their respective grade.


Finally, Python provides several ways to combine lists, each with its own advantages. As we explored different methods, from the straightforward “+” operator to the more subtle zip() function, it became clear that Python caters to a wide variety of programming styles and preferences. Depending on the task at hand, factors such as readability, memory efficiency, and the type of data being processed will determine which method is best.

Add comment

By Ranjan