Why does Python join two String Literals without operators?

Well, when a programming language does something like that, it's usually by design. In this case, as explained in the documentation :

Multiple adjacent string literals (delimited by whitespace), possibly using different quoting conventions, are allowed, and their meaning is the same as their concatenation

Translated:

Multiple adjacent (whitespace delimited) string literals, possibly using different quoting conventions (ie single or double quotes), are allowed and their meaning is the same as their concatenation.

A typical use for this feature is to create long strings that won't fit on one line.

Python has the ability to use the "triple quote" to delimit multi-line strings, for example like so:

texto_largo = """Este es un texto que ocupa
varias líneas y que por tanto he metido
dentro de unas comillas triples."""

The resulting string also contains carriage returns, as you can see if you inspect it in the shell:

>>> texto_largo
'Este es un texto que ocupa\nvarias líneas y que por tanto he metido\ndentro de unas comillas triples.'

You may not want the carriage returns to be part of the string. With the triple quote you have no way around it.

An additional problem is that the string formatted in this way breaks the indentation of the source. It's not a bug for Python, but it does make it difficult to read. Let's not say if the string in question appears inside another block that is indented, such as:

def ejemplo():
    texto = """Esta cadena
ocupa dos lineas"""
    return texto

This completely breaks readability (although python supports it). It would be much better like this:

def ejemplo():
    texto = """Esta cadena
               ocupa dos lineas"""
    return texto

The problem is that by doing this, all the spaces that we have used to indent the string remain part of it:

>>> ejemplo()
'Esta cadena\n               ocupa dos lineas'

We see then that the triple quote, although it allows writing long strings by separating them into several lines in the source, poses two problems:

1. Includes carriage returns, which we may not have wanted
2. It includes the spaces at the beginning of each line, and if we do not put them, the readability decreases drastically.

To solve both problems we can use this trick:

texto_largo = ("Este es un texto que ocupa "
               "varias líneas y que por tanto he metido "
               "en tres cadenas separadas.")

Putting it in parentheses is a trick for python to allow me to break an expression across multiple lines. Once a parenthesis is open, as long as it is not closed, Python supports carriage returns and any indentation within. It is therefore equivalent to having put the three strings next to each other on the same line (note that I have not put commas after each string, since then it would be a tuple).

Since Python will concatenate them into one, the result is equivalent to the triple quote example, only now neither the carriage returns nor the spaces in the indent are part of the string.

>>> texto_largo
'Este es un texto que ocupa varias líneas y que por tanto he metido en tres cadenas separadas.'

If you want carriage returns to be part of the resulting string, you can manually put them ( "\n") inside each chunk:

texto_largo = ("Este es un texto que ocupa\n"
               "varias líneas y que por tanto he metido\n"
               "en tres cadenas separadas.")