Convert list to string in Python

Here's how to Convert list to string in Python.

i. Here is how you can iterate through a list and convert it to a string in Python:

```python
my_list = ["Apples", "Bananas", "Cherries"]

# Iterate through list using for loop
my_str = ""
for item in my_list:
my_str += item + ", "

print(my_str)

# Output: Apples, Bananas, Cherries,
```

To remove the trailing comma and space, you can do:

```python
my_str = ""
for i in range(len(my_list)):
if i == len(my_list) - 1:
my_str += my_list[i]
else:
my_str += my_list[i] + ", "

print(my_str)

# Output: Apples, Bananas, Cherries
```

Or simpler using join():

```python
my_str = ", ".join(my_list)
print(my_str)

# Output: Apples, Bananas, Cherries
```

The join() method provides a simple way to concatenate list items into a string with a chosen separator.

ii. using the join() method is an easy way to convert a list to a string in Python. Here's an example:

```python
fruits = ['apple', 'banana', 'mango']

# Join the list items using comma
fruits_str = ', '.join(fruits)

print(fruits_str)

# Output: apple, banana, mango
```

In the join() method:
- The first parameter is the separator. Here I have passed ', ' (comma followed by space)
- The second parameter is the list you want to join

Some key points on join():

- It works on any iterable like lists, tuples, sets etc.
- The separator can be any string you like e.g. '-' or '' or '\n'
- Joining with an empty separator simply concatenates the list items.
- It returns a new string with the concatenated list items.
- The original list remains unmodified.

So in short, join() provides a quick and efficient way to convert iterables to strings in Python. It handles the iterating and concatenation neatly with just one method call.

iii. list comprehension can also be used to join a list of strings into a single string in Python. Here is an example:

```python
fruits = ['apple', 'banana', 'mango', 'orange']

fruits_str = ''.join([fruit for fruit in fruits])

print(fruits_str)
# 'applebananamangoorange'
```

Breaking this down:

- We start with the fruits list that contains string elements
- We use a list comprehension to iterate through each fruit
- Inside the comprehension, we just specify the fruit variable itself which takes the value of each element one by one
- This outputs a new list with the same string elements
- We then pass this output list to ''.join() which joins the list on the empty string '' delimiter.

So the final output is a concatenated string without any spaces or delimiters between the fruits.

The advantage of list comprehension is that it condenses the creation of the temporary list and joining operation into one neat step. But the join() method works too.

List comprehensions provide a very Pythonic approach to many tasks involving lists and strings!

iv. You can also use the map() function in Python to join a list of strings into a single string. Here is how:

```python
fruits = ['apple', 'banana', 'mango']

# Converting to str
def to_str(item):
return item

# Apply to_str to each item using map() and type cast to string
fruits_str = ''.join(map(str, fruits))

print(fruits_str)

# Output: applebananamango
```

Let's understand:

- `map()` applies a passed function to each element in an iterable
- `to_str()` function simply returns its argument - it converts the item to string
- We pass `to_str` to `map()` and supply `fruits` list as the iterable
- This applies `str()` to each fruit item
- Then we `join()` the resulting map with an empty string delimiter

So `map()` applies our string conversion logic while iterating through the list. And join() neatly concatenates everything.

Using `map()` with join() allows us to handle the conversion and concatenation in an efficient way in Python.