How to separate characters from a string to a Python list?

Question

How can I convert a string (a word, for example) into a list?

entrada:
a='carro'
saída:
['c', 'a', 'r', 'r', 'o']

I know that by using split, turn into list gets the whole word, like to know if a specific word turns to list.

Answer 1

This way returns a list of characters in each position

list(a)

See working on Coding Ground

Answer 2

Complementing the another answer, there are some cases where use only list may not be enough. See this example:

print(list('pá'))
print(list('pá'))

Although it does not seem, the two lines above are different, as this code prints the following:

['p', 'á']
['p', 'a', '́']

^{Obs: If you are testing the above code, copy and paste, because if you type directly, it may not give the desired effect. More details on this throughout the answer.}

It happens because, in a way well summarized, the Unicode defines two ways of representing the letter "a" with acute accent:

1. composite - like code point U+00E1 (LATIN SMALL LETTER A WITH ACUTE) (á)
2. decomposed - as a combination of two code points (in this order):
   • the letter "a" (without accent): U+0061 (LATIN SMALL LETTER A)
   • the acute accent: U+0301 (COMBINING ACUTE ACCENT)

The first form is called NFC, and the second, NFD. For more details about normalization, what is a code point, etc., see here, here and here. In this case, in the first line of the above code, the string is in NFC, and in the second line, it is in NFD (the third element of the list is the "acute accent" character itself - which depending on how it is rendered, can appear almost "stuck" in the closing quotes, almost imperceptible - and note that the second element is the letter "a" without accent).

The detail is that when shown on the screen, both NFC and NFD forms end up being rendered the same way, so there is no apparent difference in the two lines of code above - both show the letter "á" (and so you should copy and paste the above code to test, because if you try to type directly from the keyboard, it will preferably choose only one of the shapes and the lines will end up being identical).

And what happens is list, when receiving an iterable, builds a list in which each element of the iterable becomes an element of the list. And strings are iterable in Python, and by iterating through a string, we’re actually iterating through its code points. So there is this difference if the string is in NFD.

And since it was not specified where the strings come from, this is a situation that can happen, because the data may come from a file, HTTP request, the user copied and pasted from somewhere that was in NFD (but as it is rendered in the same way, did not notice the difference)etc. That is, it can happen without you realizing it (as it happened, for example, in this question).

---

How to solve?

For simple texts - especially if they are in Portuguese - simply normalize to NFC:

from unicodedata import normalize

print(list(normalize('NFC', 'pá')))

So I guarantee that even if the string is in NFD, the "a without accent" and "accent" characters will be "joined" in one (the "á").

Remember that this is not restricted to the Portuguese language and also works for other types of "characters":

# sim, um emoji direto no código (emojis também tem code points definidos pelo Unicode, então funciona da mesma forma)
print(list(normalize('NFC', '堆積'))) # ['', '堆', '積']

But that doesn’t always work, of course. Not all characters in the world have an NFC correspondent, and normalization to NFC will not always produce a single code point. Ex:

from unicodedata import normalize

s = 'ẛ̣'
# mesmo normalizando em NFC, ainda resulta em dois code points
print(list(normalize('NFC', s))) # ['ẛ', '̣']

Or else:

# emoji de família
s = ''.join(map(chr, [0x1f468, 0x200d, 0x1f469, 0x200d, 0x1f467, 0x200d, 0x1f467]))
print(s) # se seu browser for compatível, mostrará a família ‍‍‍
print(list(normalize('NFC', s))) # ['', '\u200d', '', '\u200d', '', '\u200d', '']

Family emojis are actually formed by several different emojis, united by one Zero Width Joiner (the \u200d shown above). So even if we normalize to NFC, still the resulting list will have separate code points.

And that doesn’t just apply to emojis, there are characters from other alphabets that have the same characteristic (they are formed by more than one code point, and even normalizing to NFC, continue with more than one):

print(list(normalize('NFC', 'नु'))) # ['न', 'ु']

This set of code points that together form "one thing" are called Grapheme Clusters. If the goal is to have a list of Grapheme Clusters (since the code points of these, separately, do not have exactly the same meaning), there is no direct way to do, and the way is to resort to external libraries.

An example is the module grapheme:

# Atenção: módulo não-nativo - Instale em https://pypi.org/project/grapheme/
from grapheme import graphemes

def to_list(s):
    return list(graphemes(s))

# emoji de família
s = ''.join(map(chr, [0x1f468, 0x200d, 0x1f469, 0x200d, 0x1f467, 0x200d, 0x1f467]))
print(to_list(s)) # ['\u200d\u200d\u200d']
print(to_list('नु')) # ['नु']

The difference, of course, is that the list elements will not always only have a code point. But this is because, thanks to all the possibilities that Unicode brings us, the definition of "character" has become more complex. Is an emoji a character (in the sense of being "a single symbol shown on the screen, which has its own meaning")? And the á in NFD, although it has two code points, it is shown as a single character, so is it acceptable to have more than one code point in each element of the list? Or I want a list in which each element is a code point, independent of normalization?

For further discussion, visit link already quoted, but anyway, the "right" solution depends on what you need (if your text will not have grapheme clusters, for example, you would not need to worry about this last part, just normalize to NFC - each case is a case).

Answer 3

It is possible to convert a string into a list. To do this, simply pass the string as a list parameter. The code below takes any string and converts it into a list.

a = list(input('Digite uma palavra: '))
print('A lista criada é: {}'.format(a))

This code takes any string and then converts it to a list.