[FIXED] What is the difference between '\' and '\n' escape sequence in python

Issue

I am coming from C language

In book of Python it is given

among escape sequence

\ - New line in a multi-line string

\n - Line break

I am confused and unable to differentiate between the two.

Solution

The book is confusing you by mixing two entirely different concepts.

• \n is an escape sequence in a string literal. Like other \single-character and \xhh or \uhhhh escape sequences, they work exactly like those in C; they define a character in the string that would otherwise be difficult to spell out when writing code.

• \ at the end of a physical line of code extends the logical line. That is, Python will see text on the next line as part of the current line, making it one long line of code. This applies anywhere in Python code.

You can trivially see the difference when you print the results of strings that use either technique:

escape_sequence = "This is a line.\nThis is another line"
logical_line_extended = "This is a logical line. \
This is still the same logical line."

print(escape_sequence)
print(logical_line_extended)

This outputs

This is a line.
This is another line
This is a logical line. This is still the same logical line.

Note that the line breaks have swapped! The \n escape sequence in the string value caused the output to be broken across two lines (the terminal or console or whatever is displaying the printed data, knows how to interpret a newline character), while the newline in the logical_line_extended string literal definition is gone; it was never part of the string value being defined, it was a newline in the source code only.

Python lets you extend a line of code like this because Python defines how you delimit logical lines very differently from C. In C, you end statements with ;, and group blocks of lines with {...} curly braces. Newlines are not part of how C reads your code.

So, the following C code:

if (a) { foo = 'bar'; spam = 'ham'; }

is the same thing as

if (a) {
    foo = 'bar';
    spam = 'ham';
}

C knows where each statement starts and ends because the programmer has to use ; and {...} to delimit lines and blocks, the language doesn't care about indentation or newlines at all here. In Python however, you explicitly use newlines and indentation to define the same structure. So Python uses whitespace instead of {, } and ;.

This means you could end up with long lines of code to hold a complex expression:

# deliberately convoluted long expression to illustrate a point
expr = 18 ** (1 / 3) / (6 * (3 + sqrt(3) * I) ** (1 / 3)) + 12 ** (1 / 3) * (3 + sqrt(3) * I) ** (1 / 3) / 12

The point of \ is to allow you to break up such a long expression across multiple logical lines by extending the current line with \ at the end:

# deliberately convoluted long expression to illustrate a point
expr = 18 ** (1 / 3) / (6 * (3 + sqrt(3) * I) ** (1 / 3)) + \
       12 ** (1 / 3) * (3 + sqrt(3) * I) ** (1 / 3) / 12

So the \ as the last character on a line, tells Python to ignore the newline that's there and continue treating the following line as part of the same logical line.

Python also extends the logical line when it has seen an opening (, [ or { brace, until the matching }, ] or ) brace is found to close the expression. This is the preferred method of extending lines. So the above expression could be broken up across multiple logical lines with:

expr = (18 ** (1 / 3) / (6 * (3 + sqrt(3) * I) ** (1 / 3)) +
        12 ** (1 / 3) * (3 + sqrt(3) * I) ** (1 / 3) / 12)

You can do the same with strings:

long_string = (
    "This is a longer string that does not contain any newline "
    "*characters*, but is defined in the source code with "
    "multiple strings across multiple logical lines."
)

This uses another C string literal trick Python borrowed: multiple consecutive string literals form one long string object once parsed and compiled.

See the Lexical analysis reference documentation:

2.1.5. Explicit line joining

Two or more physical lines may be joined into logical lines using backslash characters (\)[.]

[...]

2.1.6. Implicit line joining

Expressions in parentheses, square brackets or curly braces can be split over more than one physical line without using backslashes.

The same documentation lists all the permitted Python string escape sequences.

Answered By - Martijn Pieters