 Open in App
Not now

# Python | Append String to list

• Difficulty Level : Basic
• Last Updated : 15 Mar, 2023

, Sometimes, while working with data, we can have a problem in which we need to add elements to a container. The list can contain any type of data type. Let’s discuss certain ways in which we can perform string append operations in the list of integers.

Method #1 : Using + operator + list conversion In this method, we first convert the string into a list and then perform the task of append using + operator.

## Python3

 `# Python3 code to demonstrate working of``# Appending String to list``# using + operator + list conversion` `# initialize list``test_list ``=` `[``1``, ``3``, ``4``, ``5``]` `# initialize string``test_str ``=` `'gfg'` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# printing original string``print``(``"The original string : "` `+` `str``(test_str))` `# Appending String to list``# using + operator + list conversion``test_list ``+``=` `[test_str]` `# printing result``print``(``"The list after appending is : "` `+` `str``(test_list))`

Output

```The original list : [1, 3, 4, 5]
The original string : gfg
The list after appending is : [1, 3, 4, 5, 'gfg']```

Time Complexity: O(1)

Auxiliary Space: O(1)

Method #2: Using append() This particular function can be used to perform the operation of appending a string element to the end of a list without changing the state of the string to a list of characters.

## Python3

 `# Python3 code to demonstrate working of``# Appending String to list``# using append()` `# initialize list``test_list ``=` `[``1``, ``3``, ``4``, ``5``]` `# initialize string``test_str ``=` `'gfg'` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# printing original string``print``(``"The original string : "` `+` `str``(test_str))` `# Appending String to list``# using append()``test_list.append(test_str)` `# printing result``print``(``"The list after appending is : "` `+` `str``(test_list))`

Output

```The original list : [1, 3, 4, 5]
The original string : gfg
The list after appending is : [1, 3, 4, 5, 'gfg']```

Time Complexity: O(1)

Auxiliary Space: O(1)

Method#3: Using insert() This function is used to insert and add the element at the last of the list by using the length of the list as the index number.

## Python3

 `# Python3 code to demonstrate working of``# Appending String to list``# using insert()` `# initialize list``test_list ``=` `[``1``, ``3``, ``4``, ``5``]` `# initialize string``test_str ``=` `'gfg'` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# printing original string``print``(``"The original string : "` `+` `str``(test_str))` `# Index for insert method``index ``=` `len``(test_list)``# Appending String to list``# using insert()``test_list.insert(index, test_str)` `# printing result``print``(``"The list after appending is : "` `+` `str``(test_list))`

Output

```The original list : [1, 3, 4, 5]
The original string : gfg
The list after appending is : [1, 3, 4, 5, 'gfg']```

Time Complexity: O(1)

Auxiliary Space: O(1)

Method#4: Using extend(): This method can be used to solve this problem, extend function is used to merge the one list to the end of second list. We add a string to the end of the list by using extend function.

## Python3

 `# Python3 code to demonstrate working of``# Appending String to list``# using extend()` `# initialize list``test_list ``=` `[``1``, ``3``, ``4``, ``5``]` `# initialize string``test_str ``=` `'gfg'` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# printing original string``print``(``"The original string : "` `+` `str``(test_str))`  `# Appending String to list``# using extend()``test_list.extend([test_str])` `# printing result``print``(``"The list after appending is : "` `+` `str``(test_list))`

Output

```The original list : [1, 3, 4, 5]
The original string : gfg
The list after appending is : [1, 3, 4, 5, 'gfg']```

Time Complexity: O(1)

Auxiliary Space: O(1)

Method #5 : Using itertools.chain()
In this method, we can use itertools.chain() function to concatenate the given list and string element.

## Python3

 `# Python3 code to demonstrate working of``# Appending String to list``# using itertools.chain()``import` `itertools` `# initialize list``test_list ``=` `[``1``, ``3``, ``4``, ``5``]` `# initialize string``test_str ``=` `'gfg'` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# printing original string``print``(``"The original string : "` `+` `str``(test_str))` `# Appending String to list``# using itertools.chain()``test_list ``=` `list``(itertools.chain(test_list, [test_str]))` `# printing result``print``(``"The list after appending is : "` `+` `str``(test_list))``#this code is contributed by edula vinay kumar reddy`

Output

```The original list : [1, 3, 4, 5]
The original string : gfg
The list after appending is : [1, 3, 4, 5, 'gfg']```

Time Complexity: O(1)
Space Complexity: O(N)

Method #6:Using the slicing operator

## Python3

 `# Initialize the list``my_list ``=` `[``"apple"``, ``"banana"``, ``"cherry"``]` `# Append a string to the list``my_list ``=` `my_list[:``len``(my_list)] ``+` `[``"date"``]` `# Print the updated list``print``(my_list)` `#This code is contributed by Vinay Pinjala.`

Output

`['apple', 'banana', 'cherry', 'date']`

Time Complexity: O(N)
Space Complexity: O(1)

Method #7: Using the map() and join() method

map(str, test_str), str() is a built-in Python function that converts any value to a string. In this case, it is used to convert each character of the test_str to a single string. The map() function applies each element of the iterable object passed to it. Since we want to append the test_str to the list, we need to join the individual strings created by map() into a single string. So, “”.join(map(str, test_str)) creates a single string by joining the individual strings

## Python3

 `# initialize list``test_list ``=` `[``1``, ``3``, ``4``, ``5``]` `# initialize string``test_str ``=` `"gfg"` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# printing original string``print``(``"The original string : "` `+` `str``(test_str))` `# append string to list using map() function``test_list ``+``=` `["".join(``map``(``str``, test_str))]` `# print the updated list``print``(``"The list after appending is : "` `+` `str``(test_list))`

Output

```The original list : [1, 3, 4, 5]
The original string : gfg
The list after appending is : [1, 3, 4, 5, 'gfg']```

Time Complexity: O(N) as we are iterating to each element, where N is the size of the list
Space Complexity: O(N) as we use map function which takes O(N) space.

Method#8:Using reduce() method.

Algorithm:

1. Import the reduce function from the functools module.
2. Initialize a list test_list and a string test_str.
3. Define a lambda function concatenate that takes two arguments x and y.
4. Inside the lambda function, join the list y into a string and concatenate it to the list x.
5. Use the reduce function to apply the concatenate lambda function to test_list and test_str.
6. Store the result in the variable result_list.
7. Print the updated list.

## Python3

 `from` `functools ``import` `reduce` `# initialize list``test_list ``=` `[``1``, ``3``, ``4``, ``5``]` `# initialize string``test_str ``=` `"gfg"` `# Define a lambda function to concatenate the string to the list``concatenate ``=` `lambda` `x, y: x ``+` `["".join(``map``(``str``, y))]` `# Append the string to the list using reduce() function``result_list ``=` `reduce``(concatenate, [test_list, test_str])` `# print the updated list``print``(``"The list after appending is : "` `+` `str``(result_list))`

Output

```The list after appending is : [1, 3, 4, 5, 'gfg']
```

The time complexity of the reduce() function is O(n), where n is the number of elements in the list.
The lambda function has a time complexity of O(1) because it only performs a single concatenation operation.

The space complexity of the algorithm is O(n) because it creates a new list with the concatenated string.
Therefore, the overall time complexity of the algorithm is O(n), and the overall space complexity is O(n).

My Personal Notes arrow_drop_up