How do I concatenate two lists in Python?

Effortless List Combination: Concatenating Lists in Python

Concatenating lists in Python is a common operation when you want to merge multiple sequences into one. Python provides several intuitive ways to achieve this, allowing you to choose the method that best suits your coding style and performance needs.

Using the + Operator

The simplest way to concatenate two lists is by using the + operator:

list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2
print(combined)  # Output: [1, 2, 3, 4, 5, 6]

Key Points:

• This operation creates a new list, leaving the original lists unchanged.
• It’s a quick and easy approach, especially for short or infrequently combined lists.

Using the extend() Method

If you want to add the elements of one list to another in place, use the extend() method:

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1)  # Output: [1, 2, 3, 4, 5, 6]

Key Points:

• list1 is modified directly to include the elements of list2.
• There is no new list created. If you don’t need the original lists unaltered, this can be more memory efficient.

Using * Operator (List Unpacking)

From Python 3.5+ onwards, you can also use the * operator (unpacking) within a list literal:

list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = [*list1, *list2]
print(combined)  # Output: [1, 2, 3, 4, 5, 6]

Key Points:

• Unpacking provides a clean, modern syntax for merging lists.
• It’s especially useful when you need to combine multiple iterables or when you want to flatten nested structures easily.

Using itertools.chain

For advanced scenarios—like when you need to work with iterables that are not lists, or when you want a memory-efficient solution without creating intermediate lists—itertools.chain() is an excellent choice:

from itertools import chain

list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list(chain(list1, list2))
print(combined)  # Output: [1, 2, 3, 4, 5, 6]

Key Points:

• chain() can concatenate any iterable, not just lists.
• When you convert to a list at the end, you create a single concatenated list. Without the list() call, chain() returns a generator-like object that lazily yields elements.

Performance Considerations

• For small lists, all these methods are roughly equivalent in performance.
• For very large lists, using list.extend() or itertools.chain() tends to be more memory-efficient and slightly faster since they avoid creating intermediate lists.
• The + operator and unpacking methods create new lists, which is convenient but requires extra memory proportional to the size of the lists.

Strengthening Your Python Knowledge

Mastering basic operations, like list concatenation, sets the stage for more complex Python tasks. If you’re new to Python or looking to reinforce your fundamentals:

• Grokking Python Fundamentals: Ideal for beginners, this course gives you a strong foundation in Python’s essential features and common operations, including list handling and manipulation.

Once you’ve nailed the basics, consider enhancing your coding and problem-solving skills for technical interviews or complex projects:

• Grokking the Coding Interview: Patterns for Coding Questions: Learn essential coding patterns to streamline your approach to algorithmic challenges.
• Grokking Data Structures & Algorithms for Coding Interviews: Deepen your understanding of essential DSA concepts, ensuring that you can handle larger-scale data processing tasks efficiently.

For additional insights, code walkthroughs, and best practices, check out the DesignGurus.io YouTube channel.

In Summary

To concatenate two lists in Python:

• Use + for a quick, simple solution that creates a new list.
• Use extend() to add elements in place without creating a new list.
• Use * (list unpacking) for a concise, modern syntax.
• Use itertools.chain() for advanced or memory-efficient scenarios.

By choosing the appropriate method, you’ll write cleaner, more efficient code and be well-prepared for a wide range of list manipulation tasks.