在列表中，Python中映射为字符串和转换为字符串有什么区别？

Question

Using Python 3, I tried to join the elements of list by converting it to string. It is said that to join all the elements of a list all the elements must be converted to a string. So I just converted the whole list to a string and tried to join the list but it did not give desired output.

l = [1,2,3]
print("L type ",type(l))
print("Type of element ",type(l[0]))
d = str(l)
print("D type ",type(d))
print("Joining d ","".join(d))
print("D[0] type ",type(d[0]))
f = "".join(map(str,(l)))
print("F is ",f)
e = "".join(str(l))
print("E is ",e)

The output is:

L type  <class 'list'>
Type of element  <class 'int'>
D type  <class 'str'>
Joining d  [1, 2, 3]
D[0] type  <class 'str'>
F is  123
E is  [1, 2, 3]

But when I mapped each of the elements of the list to the string it gave the proper answer by joining the string. But if I converted the whole list to string, and each element of list is a string Eg:(D[0] type <class 'str'>) why it didnt join the elements? And if I converted elements to string at the time of joining it just returns the original list back again.

Where it differs to use map? So can anyone please explain What is the difference between mapping to string and convert to string? What is the basic criteria to join a list?

I need anyone to explain What is the difference between mapping to string and convert to string? What is the basic criteria to join a list?

Answer 1

Converting a list to a string gives you a single string -- the same string that you get when you print a list, with [ on the ends and , separating the elements.

>>> a
[1, 2, 3]
>>> str(a)
'[1, 2, 3]'

In the above REPL session, a is a list, and str(a) is a string that represents the list. (Note the quotes!)

If you join a string with '' as the seperator, you just get the same string back. It doesn't matter what the string is.

>>> ''.join(str(a))
'[1, 2, 3]'
>>> ''.join("foo")
'foo'

If you join it with a separator that's not an empty string, it's easier to see what's going on -- we're just taking each character of the string and inserting the separators in between them. The reason join behaves this way with a string is because a string is itself an iterable of strings (its individual characters).

>>> '-'.join("foo")
'f-o-o'
>>> '-'.join('[1, 2, 3]')
'[-1-,- -2-,- -3-]'
>>> '-'.join(str(a))
'[-1-,- -2-,- -3-]'

If you map the str function over a list, you get a list with each individual element transformed into a string. A map object itself doesn't have a useful string representation, but you can convert a map into a list , which does.

>>> a
[1, 2, 3]
>>> map(str, a)
<map object at 0x000002D6118DA9E0>
>>> list(map(str, a))
['1', '2', '3']

Again, note the quotes -- 1 is an int , and '1' is a str .

If we join a list of strings, we get all of the individual strings combined into a single string:

>>> ''.join(['1', '2', '3'])
'123'

and we can join a map in exactly the same way without converting it to a list first:

>>> ''.join(map(str, a))
'123'