# 5 Best Ways to Concatenate Iterables in Python

π‘ Problem Formulation: When working with data in Python, developers often need to combine multiple iterables into a single sequence. Concatenating iterables is a common task, where you might have two lists, `list_a = [1, 2, 3]` and `list_b = [4, 5, 6]`, and need to combine them into `list_c = [1, 2, 3, 4, 5, 6]`. This article demonstrates five efficient ways to achieve iterable concatenation in Python, catering to different scenarios and requirements.

## Method 1: Using the + Operator

The `+` operator is the most straightforward method for concatenating iterables that are of the same type. It’s directly understood by lists and returns a new list containing elements of the first iterable followed by elements of the second.

Here’s an example:

```list_a = [1, 2, 3]
list_b = [4, 5, 6]
list_c = list_a + list_b
print(list_c)```

Output:

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

This code snippet creates two lists, `list_a` and `list_b`, and then concatenates them using the `+` operator. The result is a new list `list_c` that contains all the elements from both lists, in order.

## Method 2: Using the itertools.chain()

The `itertools.chain()` function is part of Python’s standard utilities for working with iterators. It creates an iterator that returns elements from the first iterable until it is exhausted, then proceeds to the next iterable, until all of the iterables are exhausted.

Here’s an example:

```import itertools

iterable_a = [1, 2, 3]
iterable_b = [4, 5, 6]
combined = itertools.chain(iterable_a, iterable_b)
print(list(combined))```

Output:

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

This code imports the `itertools` module and then uses its `chain()` function to iterate over both `iterable_a` and `iterable_b`. The `list()` function is then used to convert the iterator into a list, producing the concatenated result.

## Method 3: Using the extend() Method on Lists

The `extend()` method is available on list objects in Python. It takes an iterable as an argument and appends all of its elements to the list, effectively extending the list.

Here’s an example:

```list_a = [1, 2, 3]
list_b = [4, 5, 6]
list_a.extend(list_b)
print(list_a)```

Output:

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

In this example, `extend()` is called on `list_a` with `list_b` as an argument. This adds all the elements of `list_b` to `list_a`, resulting in the concatenation of both lists.

## Method 4: Using the * Operator in Function Arguments

The `*` operator can also be used to unpack iterables into function arguments. When used within a function call, it unpacks the contents of an iterable into separate arguments.

Here’s an example:

```list_a = [1, 2, 3]
list_b = [4, 5, 6]
list_c = [*list_a, *list_b]
print(list_c)```

Output:

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

This snippet uses the `*` operator to unpack both `list_a` and `list_b` into a new list literal, combining their elements into the new list `list_c`.

## Bonus One-Liner Method 5: Using List Comprehension

The list comprehension feature in Python provides a concise way to create lists. It consists of brackets containing an expression followed by a `for` clause, then zero or more `for` or `if` clauses. This can be used for concatenating iterables.

Here’s an example:

```list_a = [1, 2, 3]
list_b = [4, 5, 6]
list_c = [item for iterable in (list_a, list_b) for item in iterable]
print(list_c)```

Output:

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

This code snippet uses a list comprehension to iterate over a tuple of lists (`list_a` and `list_b`) and for each list, iterates over its items to flatten and combine them into `list_c`.

## Summary/Discussion

• Method 1: Using the + Operator. Straightforward for lists. Creates a new list. Not efficient for large lists because it requires copying all elements.
• Method 2: Using itertools.chain(). Efficient for combining large or different types of iterables. Doesn’t immediately create a new list, saving memory. However, it returns an iterator, which needs to be converted to a list if a list is required.
• Method 3: Using the extend() Method on Lists. Changes the first list in place without creating a new list. Good for performance, but mutates the first list.
• Method 4: Using the * Operator in Function Arguments. Clear and concise for combining iterables into a new list. Requires that input iterables unpackable (like lists, tuples, etc.).
• Method 5: Using List Comprehension. Very flexible and can include conditional logic. Easy to read and can extend to more complex manipulations.