# 5 Best Ways to Append an Iterable to a List in Python

π‘ Problem Formulation: When programming in Python, it’s a common necessity to add all the elements of an iterable, like a tuple, set, or another list, to an existing list. This process is often known as extending a list. For example, if we have a list `[1, 2, 3]` and an iterable `(4, 5)`, we want to append the iterable to the list, resulting in `[1, 2, 3, 4, 5]`.

## Method 1: Using the `extend()` Method

Python lists come with a built-in method `extend()` which is specifically designed to append elements from an iterable to the end of the list. It is efficient and considered to be the idiomatic way to perform this task.

Here’s an example:

```my_list = [1, 2, 3]
my_tuple = (4, 5)
my_list.extend(my_tuple)
print(my_list)```

Output:

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

By calling `my_list.extend(my_tuple)`, we add each element of `my_tuple` to the end of `my_list`, resulting in a single, extended list.

## Method 2: Using the `+` Operator

The `+` operator can be used to concatenate a list with any iterable, returning a new list with the elements of both. However, it’s important to note that this does not modify the original list but creates a new one.

Here’s an example:

```my_list = [1, 2, 3]
my_tuple = (4, 5)
new_list = my_list + list(my_tuple)
print(new_list)```

Output:

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

This code snippet creates a new list `new_list` by concatenating `my_list` and a list created from `my_tuple`. It’s a clean one-liner but is not as memory-efficient for large lists.

## Method 3: Using List Comprehension

List comprehension is a concise way to create lists. It can be used to iterate over an iterable and append its elements to an existing list.

Here’s an example:

```my_list = [1, 2, 3]
my_tuple = (4, 5)
my_list = [item for sublist in (my_list, my_tuple) for item in sublist]
print(my_list)```

Output:

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

This snippet uses list comprehension to iterate through a tuple of lists, appending the elements of each to `my_list`. This method is both elegant and powerful but may be less readable to beginners.

## Method 4: Using the `append()` Method in a Loop

The `append()` method adds a single element to the end of a list. When combined with a loop, it can add elements from an iterable individually.

Here’s an example:

```my_list = [1, 2, 3]
my_tuple = (4, 5)
for item in my_tuple:
my_list.append(item)
print(my_list)```

Output:

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

This code uses a for loop to iterate over `my_tuple`, appending each item to `my_list` using `append()`. While straightforward, this method can be less efficient than others due to the repeated method calls in a loop.

## Bonus One-Liner Method 5: Using `*` Operator for Unpacking

The `*` operator is used for unpacking iterables. It can be used within a list to unpack and append the elements of another iterable.

Here’s an example:

```my_list = [1, 2, 3]
my_tuple = (4, 5)
my_list = [*my_list, *my_tuple]
print(my_list)```

Output:

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

This example uses unpacking to combine the original list with another iterable. The `*` operator unpacks the elements into a new list, creating a concise one-liner solution. However, similar to Method 2, this creates a new list and is not the best method for memory efficiency.

## Summary/Discussion

• Method 1: extend(): Most idiomatic and efficient for in-place extension. It does not create a new list and is suitable for appending large iterables.
• Method 2: + Operator: Clean and pythonic, but not memory efficient as it creates a new list. Suitable for small or infrequent operations.
• Method 3: List Comprehension: Very Pythonic and quite readable for those familiar with comprehensions. It offers fine-grained control over list construction but can lose efficiency with large iterables.
• Method 4: append() in a Loop: Simple and easy to understand. Less efficient due to repeated method calls but very explicit in its operations.
• Method 5: * Operator: Offers a neat one-liner but, like the + operator, creates a new list, which can be a drawback in terms of memory usage for large lists.