How to fix "SyntaxError: EOL while scanning string literal" in Python
Tags: python, syntaxerror, programming
Published: 2023-02-02 19:20:55

> ✋ **Update:** This post was originally published on my blog [decodingweb.dev](https://www.decodingweb.dev), where you can read the [latest version](https://www.decodingweb.dev/solved-syntaxerror-eol-while-scanning-string-literal-in-python) for a 💯 user experience. _~reza_

Python raises “SyntaxError: EOL while scanning string literal” when it reaches the end of the line, yet it hasn’t encountered the closing quotation mark (`'` or `"`) of a string literal.

This syntax error usually occurs owing to a missing quotation mark or an invalid multi-line string. Here’s what the error looks like:


```
File test.py, line 1
    book_title = 'Head First Python
                                  ^
SyntaxError: EOL while scanning string literal
```

Please note this is a Python 2.7 error. Python 3 displays a slightly different error for EOL and string literals.

The term "string literal" refers to every string value in your source code, like `'Head First Python'`, `'49.99'`, `'test'`, etc.

Python is an interpreted language that executes lines one after another. So every statement is assumed to be on one line. The new line marks the end of a Python statement and the beginning of another.

However, you can write loops and conditional statements in multiple lines. You can even store multi-line strings literals by using triple quotes (`"""`). You can also write multi-line statements by placing a `\` at the end of each line (except for the last line).

EOL (End of Line) in an error message usually means Python's interpreter was expecting a symbol - like a quotation mark or a bracket - but it couldn't find any, even until the end of the line.

And the error "EOL while scanning string literal" means Python was expecting a closing quotation mark, but it didn't encounter any:


```python
# 🚫 Raises: SyntaxError: EOL while scanning string literal
book_title = 'Head First Python
```

Adding the missing quotation mark resolves the issue instantly:


```python
# ✅ Correct
book_title = 'Head First Python'
```

Let's explore common scenarios that lead to this SyntaxError.

## How to fix "SyntaxError: EOL while scanning string literal"

The error "SyntaxError: EOL while scanning string literal" occurs under various scenarios:

1. <u>Forgetting to close a string literal with a quotation mark</u>
2. <u>Having a `\` right before the closing quotation mark</u>
3. <u>Open and closing quotation marks don't match</u>
4. <u>Having a multi-line string value enclosed with `"` or `'`</u>
5. <u>A missing slash!</u>
6. <u>Multi-line strings need triple quotes, not quadruple!</u>

**Forgetting to close a string literal with a quotation mark:** The most common reason behind this error is to forget to close your string with a quotation mark - whether it's a single, double, or triple quotation mark.


```python
# 🚫 Raises: SyntaxError: EOL while scanning string literal
book_title = 'Head First Python
```

Needless to say, adding the missing end fixes the problem:


```python
# ✅ Correct
book_title = 'Head First Python'
```

**Having a `\` right before the closing quotation mark:** Based on Python semantics, a pair of quotation marks work as a boundary for a string literal.

Putting a backslash before a quotation mark will turn it into an ordinary character - without any special behavior.

This is helpful when you want to include a quotation mark in your string, but you don't want it to interfer with its surrounding quotation marks:

```python
message = 'I\' m good'
```

That said, if you use the backslash before the ending quotation mark, it won't be a boundary character anymore.

Imagine you need to define a string that ends with a `\` like a file path on Windows


```python
# 🚫 Raises: SyntaxError: EOL while scanning string literal
file_dir = 'C:\files\'
```

In the above code, the last `\` escapes the quotation mark's behavior, making our string open-ended.

As a result, Python raises "SyntaxError: EOL while scanning string literal".

To fix it, we use a double backslash `\\` instead of one. As you probably know, the first `\` escapes the effect of its following slash, and as a result, we'll have our slash in the string (as an ordinary character), and the quoting behavior of `'` remains intact.


```python
# ✅ Escaping a slash in a string literal
file_dir = 'C:\files\\'
```

**Open and closing quotation marks don't match:** The opening and closing quotation marks must be identical, so if the opening is `"`, the closing must be `"` too. The following code raises the error:

```python
# 🚫 Raises: SyntaxError: EOL while scanning string literal
book_title = "Python Head First'
```

No matter which one you choose, they need to be identical:

```python
# ✅ Opening and closing quotation marks match
book_title = 'Python Head First'
```

**Having a multi-line string value enclosed with `"` or `'`:** If you use `'` or `"` to quote a string literal, Python will look for the closing quotation mark on the same line. So if you define a string literal in multiple lines enclosed in single or double quotes, you'll get the syntax error:

```python
# 🚫 Raises: SyntaxError: EOL while scanning string literal

message = 'Python is a high-level, 
general-purpose 
programming language'
```

In the above code, the first line doesn't end with a quotation mark.

If you want a string literal to span across several lines, you should use the triple quotes (`"""` or `'''`) instead:

```python
# ✅ The correct way of defining multi-line strings

message = '''Python is a high-level, 
general-purpose 
programming language'''
```

**Multi-line strings need triple quotes, not quadruple:** As mentioned earlier, to create multi-line strings, we use triple quotes. But what happens if you use quadruple quotes?

The opening would be ok, as the fourth quote would be considered a part of the string. However, the closing part will cause a SyntaxError.

Since Python expects the closing part to be triple quotes, the fourth quotation mark would be considered a separate opening - without an end part.


```python
# 🚫 Raises: SyntaxError: EOL while scanning string literal

message = ''''Python is a high-level, 
general-purpose 
programming language''''
```

Always make sure you're not using quadruple quotes by mistake.

**A missing slash:** Another way to span Python statements across multiple lines is by marking each line with a backslash. This backslash (`\`) escapes the hidden newline character (`\n`) and makes Python keeps parsing the lines until it reaches a newline character.

You can use this technique as an alternative to the triple quotes:


```python
# ✅ The correct way of defining multi-line strings with '\'

message = 'Python is a high-level, \
general-purpose \
programming language'
```

Now, if you forget the `\` in the second line, Python will expect to see the closing quotation mark on that line:


```python
# 🚫 Raises: SyntaxError: EOL while scanning string literal

message = 'Python is a high-level, \
general-purpose 
programming language'
```

If you're taking this approach, all lines should end with `\` except for the last line, which ends with the closing quotation mark.

✋ Please note: Since the `\` is supposed to escape the newline character (the hidden last character), no space should follow the `\`. In that case, the newline character wouldn't be affected, and Python will expect the statement to end on that line.

Alright, I think it does it. I hope this quick guide helped you solve your problem.

Thanks for reading.

---

❤️ **You might like:**

- [TypeError: can only concatenate str (not “float”) to str (solutions)](https://www.decodingweb.dev/python-typeerror-can-only-concatenate-str-not-float-to-str-fix)
- [TypeError: can only concatenate str (not “int”) to str (Solutions)](https://www.decodingweb.dev/python-typeerror-can-only-concatenate-str-not-int-to-str-fixed)
- [TypeError: can only concatenate str (not "bool") to str (Fixed)](https://www.decodingweb.dev/python-typeerror-can-only-concatenate-str-not-bool-to-str-fix)
- [TypeError: can only concatenate str (not "dict") to str (Fixed)](https://www.decodingweb.dev/python-typeerror-can-only-concatenate-str-not-dict-to-str-fix)
- [TypeError: can only concatenate str (not "list") to str (Fixed)](https://www.decodingweb.dev/python-typeerror-can-only-concatenate-str-not-list-to-str-fix)