Python import syntax error

Python ImportError

By Abhilasha Chougule

Python Tutorial

Python Certification Course

Programming Languages Courses

Angular JS Certification Training

Introduction to Python ImportError

In Python, we use “import” when we want to import any specific module in the Python program. In Python, to make or to allow the module contents available to the program we use import statements. Therefore when importing any module and there is any trouble in importing modules to the program then there is a chance of ImportError occurrence. In this article, we will discuss such error which generally occurs if there is an invalid declaration of import statement for module importing and such problems also known as ModuleNotFoundError in the latest versions of Python such as 3.6 and newer versions.

Examples of ImporError in Python

In Python, when we want to include the module contents in the program then we have to import these specific modules in the program. So to do this we use “import” keyword such as import statement with the module name. When writing this statement and the specified module is not written properly or the imported module is not found in the Python library then the Python interpreter throws an error known as ImportError.

Web development, programming languages, Software testing & others

There are two conditions when the ImportError will be raised. They are

• If the module does not exist.
• If we are trying to import submodule from the module

Now let us demonstrate in the below program that throws an ImportError.

Example #1

Now suppose we are trying to import module “request” which is not present or saved in Python drive where we need to download it. Let us see a small example below:

Output:

In the above sample code, we can see that we are importing a module named “request” which is not present in the downloaded Python library. Therefore it throws an ImportError which gives the message saying no module named “request”. As each module when downloaded or inbuilt it has its own private symbol table where all defined module is saved by creating separate namespace. Therefore if the module is present then there is no occurrence of such error.

In Python, there is another way of importing modules in the program and if this statement also fails then also ImportError occurs. Let us see the example below:

Example #2

Output:

In the above program, we can see another way of importing modules. This also throws ImportError if the module is not present in the private Python library.

The above two methods of importing modules in the program throw an error if the module is not present. Therefore catch such errors in exception handling concept it provides an ImportError exception which has the Python exception hierarchy as BaseException, Exception, and then comes ImportError. In Python, even moduleNotFoundError is also the same as an ImportError exception. Now let us below how to handle such error in the Python program using try and except blocks of exception handling.

Example #3

Output:

In the above program, we can see when we are trying to import the “crypt” module and we are handling this ImportError using try and except the block of exception handling. This is one way to avoid the error message to be printed.

To avoid such an ImportError exception we saw above the use of exception handling. But still, it will display the error message on the output screen. Such error occurs when there is no module present in the Python private table. To avoid this we can directly download this module from the Internet to the Python IDE. Let us see how we can avoid this ImportError we need to download the module and we will not get this error and this done as below:

If pip is installed we can directly run this to install the module. Else first we need to install the pip and then install the other packages.

Another way to download the module is to download the package directly through the Internet by downloading the module and unzip the folder and save that folder where the Python software is saved.

Conclusion – Python ImportError

In this article, we conclude that the ImportError is an exception in Python hierarchy under BaseException, Exception, and then comes this Exception. In Python, ImportError occurs when the Python program tries to import module which does not exist in the private table. This exception can be avoided using exception handling using try and except blocks. We also saw examples of how the ImportError occurs and how it is handled.

Recommended Articles

This is a guide to Python ImportError. Here we also discuss the introduction and working of import error in python along with its different examples and its code implementation. You may also have a look at the following articles to learn more –

Источник

Invalid Syntax in Python: Common Reasons for SyntaxError

Table of Contents

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Identify Invalid Python Syntax

Python is known for its simple syntax. However, when you’re learning Python for the first time or when you’ve come to Python with a solid background in another programming language, you may run into some things that Python doesn’t allow. If you’ve ever received a SyntaxError when trying to run your Python code, then this guide can help you. Throughout this tutorial, you’ll see common examples of invalid syntax in Python and learn how to resolve the issue.

By the end of this tutorial, you’ll be able to:

• Identify invalid syntax in Python
• Make sense of SyntaxError tracebacks
• Resolve invalid syntax or prevent it altogether

Free Bonus: 5 Thoughts On Python Mastery, a free course for Python developers that shows you the roadmap and the mindset you’ll need to take your Python skills to the next level.

Invalid Syntax in Python

When you run your Python code, the interpreter will first parse it to convert it into Python byte code, which it will then execute. The interpreter will find any invalid syntax in Python during this first stage of program execution, also known as the parsing stage. If the interpreter can’t parse your Python code successfully, then this means that you used invalid syntax somewhere in your code. The interpreter will attempt to show you where that error occurred.

When you’re learning Python for the first time, it can be frustrating to get a SyntaxError . Python will attempt to help you determine where the invalid syntax is in your code, but the traceback it provides can be a little confusing. Sometimes, the code it points to is perfectly fine.

Note: If your code is syntactically correct, then you may get other exceptions raised that are not a SyntaxError . To learn more about Python’s other exceptions and how to handle them, check out Python Exceptions: An Introduction.

You can’t handle invalid syntax in Python like other exceptions. Even if you tried to wrap a try and except block around code with invalid syntax, you’d still see the interpreter raise a SyntaxError .

SyntaxError Exception and Traceback

When the interpreter encounters invalid syntax in Python code, it will raise a SyntaxError exception and provide a traceback with some helpful information to help you debug the error. Here’s some code that contains invalid syntax in Python:

You can see the invalid syntax in the dictionary literal on line 4. The second entry, ‘jim’ , is missing a comma. If you tried to run this code as-is, then you’d get the following traceback:

Note that the traceback message locates the error in line 5, not line 4. The Python interpreter is attempting to point out where the invalid syntax is. However, it can only really point to where it first noticed a problem. When you get a SyntaxError traceback and the code that the traceback is pointing to looks fine, then you’ll want to start moving backward through the code until you can determine what’s wrong.

In the example above, there isn’t a problem with leaving out a comma, depending on what comes after it. For example, there’s no problem with a missing comma after ‘michael’ in line 5. But once the interpreter encounters something that doesn’t make sense, it can only point you to the first thing it found that it couldn’t understand.

Note: This tutorial assumes that you know the basics of Python’s tracebacks. To learn more about the Python traceback and how to read them, check out Understanding the Python Traceback and Getting the Most out of a Python Traceback.

There are a few elements of a SyntaxError traceback that can help you determine where the invalid syntax is in your code:

• The file name where the invalid syntax was encountered
• The line number and reproduced line of code where the issue was encountered
• A caret ( ^ ) on the line below the reproduced code, which shows you the point in the code that has a problem
• The error message that comes after the exception type SyntaxError , which can provide information to help you determine the problem

In the example above, the file name given was theofficefacts.py , the line number was 5, and the caret pointed to the closing quote of the dictionary key michael . The SyntaxError traceback might not point to the real problem, but it will point to the first place where the interpreter couldn’t make sense of the syntax.

There are two other exceptions that you might see Python raise. These are equivalent to SyntaxError but have different names:

These exceptions both inherit from the SyntaxError class, but they’re special cases where indentation is concerned. An IndentationError is raised when the indentation levels of your code don’t match up. A TabError is raised when your code uses both tabs and spaces in the same file. You’ll take a closer look at these exceptions in a later section.

Common Syntax Problems

When you encounter a SyntaxError for the first time, it’s helpful to know why there was a problem and what you might do to fix the invalid syntax in your Python code. In the sections below, you’ll see some of the more common reasons that a SyntaxError might be raised and how you can fix them.

Misusing the Assignment Operator ( = )

There are several cases in Python where you’re not able to make assignments to objects. Some examples are assigning to literals and function calls. In the code block below, you can see a few examples that attempt to do this and the resulting SyntaxError tracebacks:

The first example tries to assign the value 5 to the len() call. The SyntaxError message is very helpful in this case. It tells you that you can’t assign a value to a function call.

The second and third examples try to assign a string and an integer to literals. The same rule is true for other literal values. Once again, the traceback messages indicate that the problem occurs when you attempt to assign a value to a literal.

Note: The examples above are missing the repeated code line and caret ( ^ ) pointing to the problem in the traceback. The exception and traceback you see will be different when you’re in the REPL vs trying to execute this code from a file. If this code were in a file, then you’d get the repeated code line and caret pointing to the problem, as you saw in other cases throughout this tutorial.

It’s likely that your intent isn’t to assign a value to a literal or a function call. For instance, this can occur if you accidentally leave off the extra equals sign ( = ), which would turn the assignment into a comparison. A comparison, as you can see below, would be valid:

Most of the time, when Python tells you that you’re making an assignment to something that can’t be assigned to, you first might want to check to make sure that the statement shouldn’t be a Boolean expression instead. You may also run into this issue when you’re trying to assign a value to a Python keyword, which you’ll cover in the next section.

Misspelling, Missing, or Misusing Python Keywords

Python keywords are a set of protected words that have special meaning in Python. These are words you can’t use as identifiers, variables, or function names in your code. They’re a part of the language and can only be used in the context that Python allows.

There are three common ways that you can mistakenly use keywords:

1. Misspelling a keyword
2. Missing a keyword
3. Misusing a keyword

If you misspell a keyword in your Python code, then you’ll get a SyntaxError . For example, here’s what happens if you spell the keyword for incorrectly:

The message reads SyntaxError: invalid syntax , but that’s not very helpful. The traceback points to the first place where Python could detect that something was wrong. To fix this sort of error, make sure that all of your Python keywords are spelled correctly.

Another common issue with keywords is when you miss them altogether:

Once again, the exception message isn’t that helpful, but the traceback does attempt to point you in the right direction. If you move back from the caret, then you can see that the in keyword is missing from the for loop syntax.

You can also misuse a protected Python keyword. Remember, keywords are only allowed to be used in specific situations. If you use them incorrectly, then you’ll have invalid syntax in your Python code. A common example of this is the use of continue or break outside of a loop. This can easily happen during development when you’re implementing things and happen to move logic outside of a loop:

Here, Python does a great job of telling you exactly what’s wrong. The messages «‘break’ outside loop» and «‘continue’ not properly in loop» help you figure out exactly what to do. If this code were in a file, then Python would also have the caret pointing right to the misused keyword.

Another example is if you attempt to assign a Python keyword to a variable or use a keyword to define a function:

When you attempt to assign a value to pass , or when you attempt to define a new function called pass , you’ll get a SyntaxError and see the «invalid syntax» message again.

It might be a little harder to solve this type of invalid syntax in Python code because the code looks fine from the outside. If your code looks good, but you’re still getting a SyntaxError , then you might consider checking the variable name or function name you want to use against the keyword list for the version of Python that you’re using.

The list of protected keywords has changed with each new version of Python. For example, in Python 3.6 you could use await as a variable name or function name, but as of Python 3.7, that word has been added to the keyword list. Now, if you try to use await as a variable or function name, this will cause a SyntaxError if your code is for Python 3.7 or later.

Another example of this is print , which differs in Python 2 vs Python 3:

print is a keyword in Python 2, so you can’t assign a value to it. In Python 3, however, it’s a built-in function that can be assigned values.

You can run the following code to see the list of keywords in whatever version of Python you’re running:

keyword also provides the useful keyword.iskeyword() . If you just need a quick way to check the pass variable, then you can use the following one-liner:

This code will tell you quickly if the identifier that you’re trying to use is a keyword or not.

Missing Parentheses, Brackets, and Quotes

Often, the cause of invalid syntax in Python code is a missed or mismatched closing parenthesis, bracket, or quote. These can be hard to spot in very long lines of nested parentheses or longer multi-line blocks. You can spot mismatched or missing quotes with the help of Python’s tracebacks:

Here, the traceback points to the invalid code where there’s a t’ after a closing single quote. To fix this, you can make one of two changes:

1. Escape the single quote with a backslash ( ‘don’t’ )
2. Surround the entire string in double-quotes instead ( «don’t» )

Another common mistake is to forget to close string. With both double-quoted and single-quoted strings, the situation and traceback are the same:

This time, the caret in the traceback points right to the problem code. The SyntaxError message, «EOL while scanning string literal» , is a little more specific and helpful in determining the problem. This means that the Python interpreter got to the end of a line (EOL) before an open string was closed. To fix this, close the string with a quote that matches the one you used to start it. In this case, that would be a double quote ( » ).

Quotes missing from statements inside an f-string can also lead to invalid syntax in Python:

Here, the reference to the ages dictionary inside the printed f-string is missing the closing double quote from the key reference. The resulting traceback is as follows:

Python identifies the problem and tells you that it exists inside the f-string. The message «unterminated string» also indicates what the problem is. The caret in this case only points to the beginning of the f-string.

This might not be as helpful as when the caret points to the problem area of the f-string, but it does narrow down where you need to look. There’s an unterminated string somewhere inside that f-string. You just have to find out where. To fix this problem, make sure that all internal f-string quotes and brackets are present.

The situation is mostly the same for missing parentheses and brackets. If you leave out the closing square bracket from a list, for example, then Python will spot that and point it out. There are a few variations of this, however. The first is to leave the closing bracket off of the list:

When you run this code, you’ll be told that there’s a problem with the call to print() :

What’s happening here is that Python thinks the list contains three elements: 1 , 2 , and 3 print(foo()) . Python uses whitespace to group things logically, and because there’s no comma or bracket separating 3 from print(foo()) , Python lumps them together as the third element of the list.

Another variation is to add a trailing comma after the last element in the list while still leaving off the closing square bracket:

Now you get a different traceback:

In the previous example, 3 and print(foo()) were lumped together as one element, but here you see a comma separating the two. Now, the call to print(foo()) gets added as the fourth element of the list, and Python reaches the end of the file without the closing bracket. The traceback tells you that Python got to the end of the file (EOF), but it was expecting something else.

In this example, Python was expecting a closing bracket ( ] ), but the repeated line and caret are not very helpful. Missing parentheses and brackets are tough for Python to identify. Sometimes the only thing you can do is start from the caret and move backward until you can identify what’s missing or wrong.

Mistaking Dictionary Syntax

You saw earlier that you could get a SyntaxError if you leave the comma off of a dictionary element. Another form of invalid syntax with Python dictionaries is the use of the equals sign ( = ) to separate keys and values, instead of the colon:

Once again, this error message is not very helpful. The repeated line and caret, however, are very helpful! They’re pointing right to the problem character.

This type of issue is common if you confuse Python syntax with that of other programming languages. You’ll also see this if you confuse the act of defining a dictionary with a dict() call. To fix this, you could replace the equals sign with a colon. You can also switch to using dict() :

You can use dict() to define the dictionary if that syntax is more helpful.

Using the Wrong Indentation

There are two sub-classes of SyntaxError that deal with indentation issues specifically:

While other programming languages use curly braces to denote blocks of code, Python uses whitespace. That means that Python expects the whitespace in your code to behave predictably. It will raise an IndentationError if there’s a line in a code block that has the wrong number of spaces:

This might be tough to see, but line 5 is only indented 2 spaces. It should be in line with the for loop statement, which is 4 spaces over. Thankfully, Python can spot this easily and will quickly tell you what the issue is.

There’s also a bit of ambiguity here, though. Is the print(‘done’) line intended to be after the for loop or inside the for loop block? When you run the above code, you’ll see the following error:

Even though the traceback looks a lot like the SyntaxError traceback, it’s actually an IndentationError . The error message is also very helpful. It tells you that the indentation level of the line doesn’t match any other indentation level. In other words, print(‘done’) is indented 2 spaces, but Python can’t find any other line of code that matches this level of indentation. You can fix this quickly by making sure the code lines up with the expected indentation level.

The other type of SyntaxError is the TabError , which you’ll see whenever there’s a line that contains either tabs or spaces for its indentation, while the rest of the file contains the other. This might go hidden until Python points it out to you!

If your tab size is the same width as the number of spaces in each indentation level, then it might look like all the lines are at the same level. However, if one line is indented using spaces and the other is indented with tabs, then Python will point this out as a problem:

Here, line 5 is indented with a tab instead of 4 spaces. This code block could look perfectly fine to you, or it could look completely wrong, depending on your system settings.

Python, however, will notice the issue immediately. But before you run the code to see what Python will tell you is wrong, it might be helpful for you to see an example of what the code looks like under different tab width settings:

Notice the difference in display between the three examples above. Most of the code uses 4 spaces for each indentation level, but line 5 uses a single tab in all three examples. The width of the tab changes, based on the tab width setting:

• If the tab width is 4, then the print statement will look like it’s outside the for loop. The console will print ‘done’ at the end of the loop.
• If the tab width is 8, which is standard for a lot of systems, then the print statement will look like it’s inside the for loop. The console will print ‘done’ after each number.
• If the tab width is 3, then the print statement looks out of place. In this case, line 5 doesn’t match up with any indentation level.

When you run the code, you’ll get the following error and traceback:

Notice the TabError instead of the usual SyntaxError . Python points out the problem line and gives you a helpful error message. It tells you clearly that there’s a mixture of tabs and spaces used for indentation in the same file.

The solution to this is to make all lines in the same Python code file use either tabs or spaces, but not both. For the code blocks above, the fix would be to remove the tab and replace it with 4 spaces, which will print ‘done’ after the for loop has finished.

Defining and Calling Functions

You might run into invalid syntax in Python when you’re defining or calling functions. For example, you’ll see a SyntaxError if you use a semicolon instead of a colon at the end of a function definition:

The traceback here is very helpful, with the caret pointing right to the problem character. You can clear up this invalid syntax in Python by switching out the semicolon for a colon.

In addition, keyword arguments in both function definitions and function calls need to be in the right order. Keyword arguments always come after positional arguments. Failure to use this ordering will lead to a SyntaxError :

Here, once again, the error message is very helpful in telling you exactly what is wrong with the line.

Changing Python Versions

Sometimes, code that works perfectly fine in one version of Python breaks in a newer version. This is due to official changes in language syntax. The most well-known example of this is the print statement, which went from a keyword in Python 2 to a built-in function in Python 3:

This is one of the examples where the error message provided with the SyntaxError shines! Not only does it tell you that you’re missing parenthesis in the print call, but it also provides the correct code to help you fix the statement.

Another problem you might encounter is when you’re reading or learning about syntax that’s valid syntax in a newer version of Python, but isn’t valid in the version you’re writing in. An example of this is the f-string syntax, which doesn’t exist in Python versions before 3.6:

In versions of Python before 3.6, the interpreter doesn’t know anything about the f-string syntax and will just provide a generic «invalid syntax» message. The problem, in this case, is that the code looks perfectly fine, but it was run with an older version of Python. When in doubt, double-check which version of Python you’re running!

Python syntax is continuing to evolve, and there are some cool new features introduced in Python 3.8:

If you want to try out some of these new features, then you need to make sure you’re working in a Python 3.8 environment. Otherwise, you’ll get a SyntaxError .

Python 3.8 also provides the new SyntaxWarning . You’ll see this warning in situations where the syntax is valid but still looks suspicious. An example of this would be if you were missing a comma between two tuples in a list. This would be valid syntax in Python versions before 3.8, but the code would raise a TypeError because a tuple is not callable:

This TypeError means that you can’t call a tuple like a function, which is what the Python interpreter thinks you’re doing.

In Python 3.8, this code still raises the TypeError , but now you’ll also see a SyntaxWarning that indicates how you can go about fixing the problem:

The helpful message accompanying the new SyntaxWarning even provides a hint ( «perhaps you missed a comma?» ) to point you in the right direction!

Conclusion

In this tutorial, you’ve seen what information the SyntaxError traceback gives you. You’ve also seen many common examples of invalid syntax in Python and what the solutions are to those problems. Not only will this speed up your workflow, but it will also make you a more helpful code reviewer!

When you’re writing code, try to use an IDE that understands Python syntax and provides feedback. If you put many of the invalid Python code examples from this tutorial into a good IDE, then they should highlight the problem lines before you even get to execute your code.

Getting a SyntaxError while you’re learning Python can be frustrating, but now you know how to understand traceback messages and what forms of invalid syntax in Python you might come up against. The next time you get a SyntaxError , you’ll be better equipped to fix the problem quickly!

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Identify Invalid Python Syntax

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About Chad Hansen

Chad is an avid Pythonista and does web development with Django fulltime. Chad lives in Utah with his wife and six kids.

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

Master Real-World Python Skills
With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

What Do You Think?

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal. Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session. Happy Pythoning!

Related Tutorial Categories: basics python

Источник

It’s a sadly unhelpful error message and it’s one that you’ll see quite often when learning Python.

What does SyntaxError: invalid syntax mean?
What is Python trying to tell you with this error and how can you fix your code to make Python happy?

What is a SyntaxError in Python?

This is Python’s way of saying «I don’t understand you».
Python knows that what you’ve typed isn’t valid Python code but it’s not sure what advice to give you.

When you’re lucky, your SyntaxError will have some helpful advice in it:

$ python3 greet.py
  File "/home/trey/greet.py", line 10
    if name == "Trey"
                     ^
SyntaxError: expected ':'

But if you’re unlucky, you’ll see the message invalid syntax with nothing more:

$ python3.9 greet.py
  File "/home/trey/greet.py", line 4
    name
    ^
SyntaxError: invalid syntax

This error message gives us no hints as to what might be going on outside of a line number and a bit of highlighting indicating where Python thinks the error occurred.

Causes of SyntaxError: invalid syntax

What are the likely causes of this mysterious error message?

When my Python students hit this error, the most likely causes are typically:

1. Missing a colon (:) at the end of a line or mixing up other symbols
2. Missing opening or closing parentheses ((…)), brackets ([…]), braces ({…}), or quotes ("…")
3. Misspelled or missing keywords or mistyping syntax within a block or expression
4. Attempting to use a reserved keyword as a variable name
5. Incorrectly indented code or other whitespace errors
6. Treating statements like expressions
7. Copying Python code into the REPL or copying from the REPL into a Python file

That’s a lot of options and they’re not the only options.
How should you approach fixing this problem?

Fixing SyntaxError: invalid syntax

The first step in fixing SyntaxErrors is narrowing down the problem.

I usually take the approach of:

1. Note the line number and error message from the traceback, keeping in mind that both of these just guesses that Python’s making
2. Working through the above list of common causes
3. Attempting to read the code as Python would, looking for syntax mistakes
4. Narrowing down the problem by removing blocks of code that I suspect may be the culprit

It’s easier to address that dreaded SyntaxError: invalid syntax exception when you’re familiar with its most common causes.
Let’s attempt to build up our intuitions around SyntaxError: invalid syntax by touring the common causes of this error message.

Upgrading Python improves error messages

Before diving into specific errors, note that upgrading your Python version can drastically improve the helpfulness of common error messages.

Take this error message:

$ python3 square.py
  File "/home/trey/square.py", line 2
    return [
    ^
SyntaxError: invalid syntax

On Python 3.10 it looks considerably different:

$ python3.10 square.py
  File "/home/trey/square.py", line 1
    def square_all(numbers:
                  ^
SyntaxError: '(' was never closed

We’re running the same square.py file in both cases:

def square_all(numbers:
    return [
        n**2
        for n in numbers
    ]

But Python 3.10 showed a much more helpful message: the line number, the position, and the error message itself are all much clearer for many unclosed parentheses and braces on Python 3.10 and above.

The dreaded missing colon is another example.
Any expression that starts a new block of code needs a : at the end.

Here’s the error that Python 3.9 shows for a missing colon:

$ python3 greet.py
  File "/home/trey/greet.py", line 10
    if name == "Trey"
                     ^
SyntaxError: invalid syntax

And here’s the same error in Python 3.10:

$ python3 greet.py
  File "/home/trey/greet.py", line 10
    if name == "Trey"
                     ^
SyntaxError: expected ':'

Much more helpful, right?
It’s still a SyntaxError exception, but the message is much clearer than simply invalid syntax.

Python 3.10 also includes friendlier error messages when you use = where you likely meant ==:

>>> name = "Trey"
>>> if name = "Trey":
  File "<stdin>", line 1
    if name = "Trey":
       ^^^^^^^^^^^^^
SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?

Newer Python versions include more helpful error messages for missing commas, inline if expressions, unclosed braces/brackets/parentheses, and more.

If you have the ability to run your code on a newer version of Python, try it out.
It might help you troubleshoot your syntax errors more effectively.

Count your parentheses

Forgetting closing parentheses, brackets, and braces is also a common source of coding errors.

Fortunately, recent Python versions have started noting unclosed brackets in their SyntaxError messages.

When running this code:

def colors():
    c = ['red',
        'blue',
    return c

Python 3.9 used to show simply invalid syntax:

$ python3.9 colors.py
  File "/home/trey/colors.py", line 4
    return c
    ^
SyntaxError: invalid syntax

But Python 3.10 shows a more helpful error message:

$ python3.10 colors.py
  File "/home/trey/colors.py", line 2
    c = ['red',
        ^
SyntaxError: '[' was never closed

But sometimes Python can get a little confused when guessing the cause of an error.
Take this populate.py script:

import random
import names

random_list=["a1","a2","a3","b1","b2","b3","c1","c2","c3"]

with open("one.txt","w+") as one, 
     open("two.txt","w+") as two, 
     open("three.txt","w+") as three:
      for i in range(0,3):
          one.write("%sn" "%s" % (names.get_first_name(),
              random.choice(random_list))
          two.write("%sn" "%s" % (names.get_first_name(),
              random.choice(random_list))
          three.write("%sn" "%s" % (names.get_first_name(),
              random.choice(random_list))

When running this script, Python 3.10 shows this error message:

$ python3.10 populate.py
  File "/home/trey/populate.py", line 9
    one.write("%sn" "%s" %
              ^^^^^^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?

The problem is that all 3 of those write method calls are missing closing parentheses.

Count your parentheses!

Many code editors highlight matching parentheses, brackets, and braces (when your cursor is at an opening parentheses the closing one will change color).
Use your code editor to see if each pair of parenthesis matches up properly (and that the one in matches seems correct).

Misspelled, missing, or misplaced keywords

Can you see what’s wrong with this line of code?

>>> drf sum_of_squares(numbers):
  File "<stdin>", line 1
    drf sum_of_squares(numbers):
        ^
SyntaxError: invalid syntax

We were trying to define a function, but we misspelled def as drf.
Python couldn’t figure out what we were trying to do, so it showed us that generic invalid syntax message.

What about this one?

>>> numbers = [2, 1, 3, 4, 7, 11, 18]
>>> squares = [n**2 for numbers]
  File "<stdin>", line 1
    squares = [n**2 for numbers]
                               ^
SyntaxError: invalid syntax

Python’s pointing to the end of our comprehension and saying there’s a syntax error.
But why?

Look a bit closer.
There’s something missing in our comprehension.

We meant type this:

>>> numbers = [2, 1, 3, 4, 7, 11, 18]
>>> squares = [n**2 for n in numbers]

We were missing the in in our comprehension’s looping component.

Misspelled keywords and missing keywords often result in that mysterious invalid syntax, but extra keywords can cause trouble as well.

You can’t use reserved words as variable names in Python:

>>> class = "druid"
  File "<stdin>", line 1
    class = "druid"
          ^
SyntaxError: invalid syntax

Python sees that word class and it assumes we’re defining a class.
But then it sees an = sign and gets confused and can’t tell what we’re trying to do, so it throws its hands in the error and yells invalid syntax!

This one is a bit more mysterious:

>>> import urlopen from urllib.request
  File "<stdin>", line 1
    import urlopen from urllib.request
                   ^^^^
SyntaxError: invalid syntax

That looks right, doesn’t it?
So what’s the problem?

In Python the import…from syntax is actually a from…import syntax.
We meant to write this instead:

>>> from urllib.request import urlopen

Watch out for misspelled keywords, missing keywords, and re-arranged syntax.
Also be sure not to use reserved words as variable names (e.g. class, return, and import are invalid variable names).

Subtle spacing problems

Can you see what’s wrong in this code?

>>> class Thing:
...     def __init _(self, name, color):
  File "<stdin>", line 2
    def __init _(self, name, color):
               ^
SyntaxError: invalid syntax

Notice the extra space in the function name (__init_ _ instead of __init__)?

Can you identify what’s wrong in this line?

>>> class Thing:
...     def__init__(self, name, color):
  File "<stdin>", line 2
    def__init__(self, name, color):
                                  ^
SyntaxError: invalid syntax

This one might be harder to spot.

Everything on that line is correct except that there’s no space between def and __init__.

When one space character is valid, you can usually use more than one space character as well.
But adding an extra space in the middle of an identifier or removing spaces where there should be spaces can often cause syntax errors.

Forgotten quotes and extra quotes

If you code infrequently, you likely forget to put quotes around your strings often.
This is a very common mistake, so rest assured that you’re not alone!

Forgotten quotes can sometimes result in this cryptic invalid syntax error message:

>>> print(Four!) if n
  File "<stdin>", line 1
    print(Four!) if n
              ^
SyntaxError: invalid syntax

Be careful with quotes within quotes:

>>> question = 'What's that?'
  File "<stdin>", line 1
    question = 'What's that?'
                     ^
SyntaxError: invalid syntax

You’ll need to switch to a different quote style (using double quotes for example) or escape those quotes.

Mixing up your symbols

Sometimes your syntax might look correct but you’ve actually confused one bit of syntax for another common bit of syntax.

That’s what happened here:

>>> things = {duck='purple', monkey='green'}
  File "<stdin>", line 1
    things = {duck='purple', monkey='green'}
              ^^^^^^^^^^^^^
SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?

We’re trying to make a dictionary and we’ve accidentally used = instead of : to separate our key-value pairs.

Here’s another dictionary symbol mix up:

>>> states = [
...     'Oregon': 'OR',
  File "<stdin>", line 2
    'Oregon': 'OR',
            ^
SyntaxError: invalid syntax

It looks like we’re trying to define a dictionary, but we started with an open square bracket ([) instead of an open curly brace ({).

Another common syntax mistake is missing periods:

  File "/home/trey/file_info.py", line 15
    size = path.stat()st_size
                      ^^^^^^^
SyntaxError: invalid syntax

We’re trying to access the st_size attribute on the object returned from that path.stat() call, but we’ve forgot to put a . before st_size.

Sometimes syntax errors are due to characters being swapped around:

>>> name = "Trey"
>>> name[]0
  File "<stdin>", line 1
    name[]0
         ^
SyntaxError: invalid syntax

And some syntax errors are due to extra symbols you didn’t intend to write:

>>> name = "Trey"
>>> name.lower.()
  File "<stdin>", line 1
    name.lower.()
               ^
SyntaxError: invalid syntax

We wrote an extra . before our parentheses above.

Indentation errors in disguise

Sometimes a SyntaxError is actually an indentation error in disguise.

For example this code has an else clause that’s too far indented:

import sys

name = sys.argv[1]

if name == "Trey":
    print("I know you")
    print("Your name is Troy... no, Trent? Trevor??")
    else:
        print("Hello stranger")

When we run the code we’ll see a SyntaxError:

$ python greet.py
  File "/home/trey/greet.py", line 8
    else:
    ^^^^
SyntaxError: invalid syntax

Indentation issues often result in IndentationError exceptions, but sometimes they’ll manifest as SyntaxError exceptions instead.

Embedding statements within statements

A «statement» is either a block of Python code or a single line of Python code that can stand on its own.

An «expression» is a chunk of Python code that evaluates to a value.
Expressions contain identifiers (i.e. variables), literals (e.g. [1, 2], "hi", and 4), and operators (e.g. +, in, and *).

In Python we can embed one expression within another.
But some expressions are actually «statements» which must be a line all on their own.

Here we’ve tried to embed one statement within another:

>>> def square_all(numbers):
...     return result = [n**2 for n in numbers]
  File "<stdin>", line 2
    return result = [n**2 for n in numbers]
                  ^
SyntaxError: invalid syntax

Assignments are statements in Python (result = ... is a statement).
Python’s return is also a statement.
We’ve tried to embed one statement inside another and Python didn’t understand us.

We likely meant either this:

def square_all(numbers):
    result = [n**2 for n in numbers]
    return result

Or this:

def square_all(numbers):
    return [n**2 for n in numbers]

Here’s the same issue with the global statement (see assigning to global variables):

>>> def connect(*args, **kwargs):
...     global _connection = sqlite3.connect(*args, **kwargs)
  File "<stdin>", line 2
    global _connection = sqlite3.connect(*args, **kwargs)
                       ^
SyntaxError: invalid syntax

And the same issue with the del statement:

trey_count = del counts['Trey']
  File "<stdin>", line 1
    trey_count = del counts['Trey']
                 ^^^
SyntaxError: invalid syntax

If assignment is involves in your statement-inside-a-statement, an assignment expression (via Python’s walrus operator) may be helpful in resolving your issue.
Though often the simplest solution is to split your code into multiple statements over multiple lines.

Errors that appear only in the Python REPL

Some errors are a bit less helpful within the Python REPL.

Take this invalid syntax error:

def square_all(numbers:
    return [
  File "<stdin>", line 2
    return [
    ^^^^^^
SyntaxError: invalid syntax

We’ll see that error within the Python REPL even on Python 3.11.

The issue is that the first line doesn’t have a closing parentheses.
Python 3.10+ would properly point this out if we ran our code from a .py file instead:

$ python3.10 square.py
  File "/home/trey/square.py", line 1
    def square_all(numbers:
                  ^
SyntaxError: '(' was never closed

But at the REPL Python doesn’t parse our code the same way (it parses block-by-block in the REPL) and sometimes error messages are a bit less helpful within the REPL as a result.

Here’s another REPL-specific error:

>>> def greet(name):
...     print(f"Howdy {name}!")
... greet("Trey")
  File "<stdin>", line 3
    greet("Trey")
    ^^^^^
SyntaxError: invalid syntax

This is valid Python code:

def greet(name):
    print(f"Howdy {name}!")
greet("Trey")

But that can’t be copy-pasted directly into the REPL.
In the Python REPL a blank line is needed after a block of code to end that block.

So we’d need to put a newline between the function definition and the function call:

>>> def greet(name):
...     print(f"Howdy {name}!")
...
>>> greet("Trey")
Howdy Trey!

Some errors are due to code that feels like it should work in a Python REPL but doesn’t.
For example running python from within your Python REPL doesn’t work:

>>> python greet.py
  File "<stdin>", line 1
    python greet.py
           ^^^^^
SyntaxError: invalid syntax
>>> python -m pip install django
  File "<stdin>", line 1
    python -m pip install django
              ^^^
SyntaxError: invalid syntax

The above commands would work from our system command-prompt, but they don’t work within the Python REPL.

If you’re trying to launch Python or send a command to your prompt outside Python (like ls or dir), you’ll need to do it from your system command prompt (Terminal, Powershell, Command Prompt, etc.).
You can only type valid Python code from within the Python REPL.

Problems copy-pasting from the REPL

Copy-pasting from the Python REPL into a .py file will also result in syntax errors.

Here’s we’re running a file that has >>> prefixes before each line:

$ python numbers.py
  File "/home/trey/numbers.py", line 1
    >>> n = 4
    ^^
SyntaxError: invalid syntax

This isn’t a valid Python program:

>>> n = 4
>>> print(n**2)

But this is a valid Python program:

You’ll need to be careful about empty lines when copy-pasting from a .py file into a Python REPL and you’ll need to be careful about >>> and ... prefixes and command output when copy-pasting from a REPL into a .py file.

The line number is just a «best guess»

It used to be that the line number for an error would usually represent the place that Python got confused about your syntax.
That line number was often one or more lines after the actual error.

In recent versions of Python, the core developers have updated these line numbers in an attempt to make them more accurate.

For example here’s an error on Python 3.9 due to a missing comma:

$ python3.9 greet.py
  File "/home/trey/greet.py", line 4
    name
    ^
SyntaxError: invalid syntax

And here’s the same error in Python 3.10:

$ python3.10 greet.py
  File "/home/greet.py", line 3
    "Hello there"
    ^^^^^^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?

Python’s given us a helpful hint on Python 3.10.
But it’s also made a different guess about what line the error is on.

As you can see from the greet.py file, line 3 ("Hello there") is the better guess in this case, as that’s where the comma is needed.

def greet(name):
    print(
        "Hello there"
        name
    )

While deciphering tracebacks, keep in mind that the line number is just Python’s best guess as to where the error occurred.

SyntaxError exceptions happen all the time

If your code frequently results in SyntaxError exceptions, don’t fret.
These kinds of exceptions happen all the time.
When you’re newer to Python, you’ll find that it’s often a challenge to remember the exact syntax for the statements you’re writing.

But more experienced Python programmers also experience syntax errors.
I make typos in my code quite often.
I have a linter installed in my text editor to help me catch those typos though.
I recommend searching for a «Python» or «Python linter» extension for your favorite code editor so you can spot these issues quickly every time you save your .py files.

Once you get past syntax errors, you’ll likely hit other types of exceptions. Watch the exception screencast series for more on reading tracebacks and exception handling in Python.

Неверный синтаксис в Python

Когда вы запускаете ваш код Python, интерпретатор сначала анализирует его, чтобы преобразовать в байтовый код Python, который он затем выполнит. Интерпретатор найдет любой недопустимый синтаксис в Python на этом первом этапе выполнения программы, также известном как этап синтаксического анализа . Если интерпретатор не может успешно проанализировать ваш код Python, это означает, что вы использовали неверный синтаксис где-то в вашем коде. Переводчик попытается показать вам, где произошла эта ошибка.

Когда вы изучаете Python в первый раз, может быть неприятно получить + SyntaxError +. Python попытается помочь вам определить, где в вашем коде указан неверный синтаксис, но предоставляемый им traceback может немного сбить с толку. Иногда код, на который он указывает, вполне подходит.

*Примечание:* Если ваш код *синтаксически* правильный, то вы можете получить другие исключения, которые не являются `+ SyntaxError +`. Чтобы узнать больше о других исключениях Python и о том, как их обрабатывать, ознакомьтесь с https://realpython.com/python-exceptions/[Python Exceptions: Введение].

Вы не можете обрабатывать неправильный синтаксис в Python, как и другие исключения. Даже если вы попытаетесь обернуть блок + try + и + кроме + вокруг кода с неверным синтаксисом, вы все равно увидите, что интерпретатор вызовет + SyntaxError +.

+ SyntaxError + Исключение и трассировка

Когда интерпретатор обнаруживает неверный синтаксис в коде Python, он вызовет исключение + SyntaxError + и предоставит трассировку с некоторой полезной информацией, которая поможет вам отладить ошибку. Вот некоторый код, который содержит недопустимый синтаксис в Python:

 1 # theofficefacts.py
 2 ages = {
 3     'pam': 24,
 4     'jim': 24
 5     'michael': 43
 6 }
 7 print(f'Michael is {ages["michael"]} years old.')

Вы можете увидеть недопустимый синтаксис в литерале словаря в строке 4. Во второй записи + 'jim' + пропущена запятая. Если вы попытаетесь запустить этот код как есть, вы получите следующую трассировку:

$ python theofficefacts.py
File "theofficefacts.py", line 5
    'michael': 43
            ^
SyntaxError: invalid syntax

Обратите внимание, что сообщение трассировки обнаруживает ошибку в строке 5, а не в строке 4. Интерпретатор Python пытается указать, где находится неправильный синтаксис. Тем не менее, он может только указать, где он впервые заметил проблему. Когда вы получите трассировку + SyntaxError + и код, на который указывает трассировка, выглядит нормально, тогда вы захотите начать движение назад по коду, пока не сможете определить, что не так.

В приведенном выше примере нет проблемы с запятой, в зависимости от того, что следует после нее. Например, нет проблемы с отсутствующей запятой после + 'michael' + в строке 5. Но как только переводчик сталкивается с чем-то, что не имеет смысла, он может лишь указать вам на первое, что он обнаружил, что он не может понять.

*Примечание:* В этом руководстве предполагается, что вы знакомы с основами *tracebacks* в Python. Чтобы узнать больше о трассировке Python и о том, как их читать, ознакомьтесь с https://realpython.com/python-traceback/[Understanding Python Traceback].

Существует несколько элементов трассировки + SyntaxError +, которые могут помочь вам определить, где в вашем коде содержится неверный синтаксис:

В приведенном выше примере имя файла было + theofficefacts.py +, номер строки был 5, а каретка указывала на закрывающую кавычку из словарного ключа + michael +. Трассировка + SyntaxError + может не указывать на реальную проблему, но она будет указывать на первое место, где интерпретатор не может понять синтаксис.

Есть два других исключения, которые вы можете увидеть в Python. Они эквивалентны + SyntaxError +, но имеют разные имена:

Оба эти исключения наследуются от класса + SyntaxError +, но это особые случаи, когда речь идет об отступе. + IndentationError + возникает, когда уровни отступа вашего кода не совпадают. + TabError + возникает, когда ваш код использует и табуляцию, и пробелы в одном файле. Вы познакомитесь с этими исключениями более подробно в следующем разделе.

Общие проблемы с синтаксисом

Когда вы впервые сталкиваетесь с + SyntaxError +, полезно знать, почему возникла проблема и что вы можете сделать, чтобы исправить неверный синтаксис в вашем коде Python. В следующих разделах вы увидите некоторые из наиболее распространенных причин, по которым может быть вызвано «+ SyntaxError +», и способы их устранения.

>>> len('hello') = 5
  File "<stdin>", line 1
SyntaxError: can't assign to function call

>>> 'foo' = 1
  File "<stdin>", line 1
SyntaxError: can't assign to literal

>>> 1 = 'foo'
  File "<stdin>", line 1
SyntaxError: can't assign to literal

*Примечание:* В приведенных выше примерах отсутствует повторяющаяся строка кода и каретка (`+ ^ +`), указывающая на проблему в трассировке. Исключение и обратная трассировка, которые вы видите, будут другими, когда вы находитесь в REPL и пытаетесь выполнить этот код из файла. Если бы этот код был в файле, то вы бы получили повторяющуюся строку кода и указали на проблему, как вы видели в других случаях в этом руководстве.

>>> len('hello') == 5
True

>>> fro i in range(10):
  File "<stdin>", line 1
    fro i in range(10):
        ^
SyntaxError: invalid syntax

>>> for i range(10):
  File "<stdin>", line 1
    for i range(10):
              ^
SyntaxError: invalid syntax

>>> names = ['pam', 'jim', 'michael']
>>> if 'jim' in names:
...     print('jim found')
...     break
...
  File "<stdin>", line 3
SyntaxError: 'break' outside loop

>>> if 'jim' in names:
...     print('jim found')
...     continue
...
  File "<stdin>", line 3
SyntaxError: 'continue' not properly in loop

>>> pass = True
  File "<stdin>", line 1
    pass = True
         ^
SyntaxError: invalid syntax

>>> def pass():
  File "<stdin>", line 1
    def pass():
           ^
SyntaxError: invalid syntax

import keyword
print(keyword.kwlist)

>>> import keyword; keyword.iskeyword('pass')
True

>>> message = 'don't'
  File "<stdin>", line 1
    message = 'don't'
                   ^
SyntaxError: invalid syntax

>>> message = "This is an unclosed string
  File "<stdin>", line 1
    message = "This is an unclosed string
                                        ^
SyntaxError: EOL while scanning string literal

 1 # theofficefacts.py
 2 ages = {
 3     'pam': 24,
 4     'jim': 24,
 5     'michael': 43
 6 }
 7 print(f'Michael is {ages["michael]} years old.')

$ python theofficefacts.py
  File "theofficefacts.py", line 7
    print(f'Michael is {ages["michael]} years old.')
         ^
SyntaxError: f-string: unterminated string

# missing.py
def foo():
    return [1, 2, 3

print(foo())

$ python missing.py
  File "missing.py", line 5
    print(foo())
        ^
SyntaxError: invalid syntax

# missing.py
def foo():
    return [1, 2, 3,

print(foo())

$ python missing.py
  File "missing.py", line 6

                ^
SyntaxError: unexpected EOF while parsing

>>> ages = {'pam'=24}
  File "<stdin>", line 1
    ages = {'pam'=24}
                 ^
SyntaxError: invalid syntax

>>> ages = dict(pam=24)
>>> ages
{'pam': 24}

 1 # indentation.py
 2 def foo():
 3     for i in range(10):
 4         print(i)
 5   print('done')
 6
 7 foo()

$ python indentation.py
  File "indentation.py", line 5
    print('done')
                ^
IndentationError: unindent does not match any outer indentation level

 1 # indentation.py
 2 def foo():
 3     for i in range(10):
 4         print(i)
 5     print('done')
 6
 7 foo()

$ tabs 4 # Sets the shell tab width to 4 spaces
$ cat -n indentation.py
     1   # indentation.py
     2   def foo():
     3       for i in range(10)
     4           print(i)
     5       print('done')
     6
     7   foo()

$ tabs 8 # Sets the shell tab width to 8 spaces (standard)
$ cat -n indentation.py
     1   # indentation.py
     2   def foo():
     3       for i in range(10)
     4           print(i)
     5           print('done')
     6
     7   foo()

$ tabs 3 # Sets the shell tab width to 3 spaces
$ cat -n indentation.py
     1   # indentation.py
     2   def foo():
     3       for i in range(10)
     4           print(i)
     5      print('done')
     6
     7   foo()

$ python indentation.py
  File "indentation.py", line 5
    print('done')
                ^
TabError: inconsistent use of tabs and spaces in indentation

>>> def fun();
  File "<stdin>", line 1
    def fun();
             ^
SyntaxError: invalid syntax

>>> def fun(a, b):
...     print(a, b)
...
>>> fun(a=1, 2)
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument

>>> # Valid Python 2 syntax that fails in Python 3
>>> print 'hello'
  File "<stdin>", line 1
    print 'hello'
                ^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print('hello')?

>>> # Any version of python before 3.6 including 2.7
>>> w ='world'
>>> print(f'hello, {w}')
  File "<stdin>", line 1
    print(f'hello, {w}')
                      ^
SyntaxError: invalid syntax

>>> [(1,2)(2,3)]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object is not callable

>>> [(1,2)(2,3)]
<stdin>:1: SyntaxWarning: 'tuple' object is not callable; perhaps you missed a comma?
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object is not callable

Заключение

В этом руководстве вы увидели, какую информацию предоставляет обратная связь + SyntaxError +. Вы также видели много распространенных примеров неправильного синтаксиса в Python и каковы решения этих проблем. Это не только ускорит ваш рабочий процесс, но и сделает вас более полезным рецензентом кода!

Когда вы пишете код, попробуйте использовать IDE, который понимает синтаксис Python и предоставляет обратную связь. Если вы поместите многие из недопустимых примеров кода Python из этого руководства в хорошую IDE, то они должны выделить проблемные строки, прежде чем вы даже сможете выполнить свой код.

Получение + SyntaxError + во время изучения Python может быть неприятным, но теперь вы знаете, как понимать сообщения трассировки и с какими формами недопустимого синтаксиса в Python вы можете столкнуться. В следующий раз, когда вы получите + SyntaxError +, у вас будет больше возможностей быстро решить проблему!

SyntaxError — это ошибка, которая легко может ввести в ступор начинающего программиста. Стоит забыть одну запятую или не там поставить кавычку и Python наотрез откажется запускать программу. Что ещё хуже, по выводу в консоль сложно сообразить в чём дело. Выглядят сообщения страшно и непонятно. Что с этим делать — не ясно. Вот неполный список того, что можно встретить:

• SyntaxError: invalid syntax
• SyntaxError: EOL while scanning string literal
• SyntaxError: unexpected EOF while parsing

Эта статья о том, как справиться с синтаксической ошибкой SyntaxError. Дочитайте её до конца и получите безотказный простой алгоритм действий, что поможет вам в трудную минуту — ваш спасательный круг.

Работать будем с программой, которая выводит на экран список учеников. Её код выглядит немного громоздко и, возможно, непривычно. Если не всё написанное вам понятно, то не отчаивайтесь, чтению статьи это не помешает.

students = [
    ['Егор', 'Кузьмин'],
    ['Денис', 'Давыдов'],
]

for first_name, last_name in students:
    label = 'Имя ученика: {first_name} {last_name}'.format(
        first_name = first_name
        last_name = last_name
    )

    print(label)

Ожидается примерно такой результат в консоли:

$ python script.py
Имя ученика: Егор Кузьмин
Имя ученика: Денис Давыдов

Но запуск программы приводит к совсем другому результату. Скрипт сломан:

$ python script.py
  File "script.py", line 9
    last_name = last_name
            ^
SyntaxError: invalid syntax

Ошибки в программе бывают разные и каждой нужен свой особый подход. Первым делом внимательно посмотрите на вывод программы в консоль. На последней строчке написано SyntaxError: invalid syntax. Если эти слова вам не знакомы, то обратитесь за переводом к Яндекс.Переводчику:

SyntaxError: недопустимый синтаксис
SyntaxError: неверный синтаксис

Первое слово SyntaxError Яндекс не понял. Помогите ему и разделите слова пробелом:

Syntax Error: invalid syntax
Синтаксическая ошибка: неверный синтаксис

Теория. Синтаксические ошибки

Программирование — это не магия, а Python — не волшебный шар. Он не умеет предсказывать будущее, у него нет доступа к секретным знаниями, это просто автомат, это программа. Узнайте как она работает, как ищет ошибки в коде, и тогда легко найдете эффективный способ отладки. Вся необходимая теория собрана в этом разделе, дочитайте до конца.

SyntaxError — это синтаксическая ошибка. Она случается очень рано, еще до того, как Python запустит программу. Вот что делает компьютер, когда вы запускаете скрипт командой python script.py:

1. запускает программу python
2. python считывает текст из файла script.py
3. python превращает текст программы в инструкции
4. python исполняет инструкции

Синтаксическая ошибка SyntaxError возникает на четвёртом этапе в момент, когда Python разбирает текст программы на понятные ему компоненты. Сложные выражения в коде он разбирает на простейшие инструкции. Вот пример кода и инструкции для него:

person = {'name': 'Евгений'}

Инструкции:

1. создать строку 'Евгений'
2. создать словарь
3. в словарь добавить ключ 'name' со значением 'Евгений'
4. присвоить результат переменной person

SyntaxError случается когда Python не смог разбить сложный код на простые инструкции. Зная это, вы можете вручную разбить код на инструкции, чтобы затем проверить каждую из них по отдельности. Ошибка прячется в одной из инструкций.

1. Найдите поломанное выражение

Этот шаг сэкономит вам кучу сил. Найдите в программе сломанный участок кода. Его вам предстоит разобрать на отдельные инструкции. Посмотрите на вывод программы в консоль:

$ python script.py
  File "script.py", line 9
    last_name = last_name
            ^
SyntaxError: invalid syntax

Вторая строчка сообщает: File "script.py", line 9 — ошибка в файле script.py на девятой строчке. Но эта строка является частью более сложного выражения, посмотрите на него целиком:

label = 'Имя ученика: {first_name} {last_name}'.format(
    first_name = first_name
    last_name = last_name
)

2. Разбейте выражение на инструкции

В прошлых шагах вы узнали что сломан этот фрагмент кода:

label = 'Имя ученика: {first_name} {last_name}'.format(
    first_name = first_name
    last_name = last_name
)

Разберите его на инструкции:

1. создать строку 'Имя ученика: {first_name} {last_name}'
2. получить у строки метод format
3. вызвать функцию с двумя аргументами
4. результат присвоить переменной label

Так выделил бы инструкции программист, но вот Python сделать так не смог и сломался. Пора выяснить на какой инструкции нашла коса на камень.

Теперь ваша задача переписать код так, чтобы в каждой строке программы исполнялось не более одной инструкции из списка выше. Так вы сможете тестировать их по отдельности и облегчите себе задачу. Так выглядит отделение инструкции по созданию строки:

# 1. создать строку
template = 'Имя ученика: {first_name} {last_name}'

label = template.format(
    first_name = first_name
    last_name = last_name
)

Сразу запустите код, проверьте что ошибка осталась на прежнему месте. Приступайте ко второй инструкции:

# 1. создать строку
template = 'Имя ученика: {first_name} {last_name}'

# 2. получить у строки метод
format = template.format

label = format(
    first_name = first_name
    last_name = last_name
)

Строка format = template.format создает новую переменную format и кладёт в неё функцию. Да, да, это не ошибка! Python разрешает класть в переменные всё что угодно, в том числе и функции. Новая переменная переменная format теперь работает как обычная функция, и её можно вызвать: format(...).

Снова запустите код. Ошибка появится внутри format. Под сомнением остались две инструкции:

1. вызвать функцию с двумя аргументами
2. результат присвоить переменной label

Скорее всего, Python не распознал вызов функции. Проверьте это, избавьтесь от последней инструкции — от создания переменной label:

# 1. создать строку
template = 'Имя ученика: {first_name} {last_name}'

# 2. получить у строки метод
format = template.format

# 3. вызвать функцию
format(
    first_name = first_name
    last_name = last_name
)

Запустите код. Ошибка снова там же — внутри format. Выходит, код вызова функции написан с ошибкой, Python не смог его превратить в инструкцию.

3. Проверьте синтаксис вызова функции

Теперь вы знаете что проблема в коде, вызывающем функцию. Можно помедитировать еще немного над кодом программы, пройтись по нему зорким взглядом еще разок в надежде на лучшее. А можно поискать в сети примеры кода для сравнения.

Запросите у Яндекса статьи по фразе “Python синтаксис функции”, а в них поищите код, похожий на вызов format и сравните. Вот одна из первых статей в поисковой выдаче:

• Функции в Python

Уверен, теперь вы нашли ошибку. Победа!

I have the following code for the beginnings of a snake game:

import os
import pygame
import math
import random
from pygame import *
from pygame import key.get_pressed
 


class cube(object):
    rows = 20
    w = 500
    def __init__(self,start,dirnx=1,dirny=0,color=(255,0,0)):
        self.pos = start
        self.dirnx = 1
        self.dirny = 0
        self.color = color

    def move(self, dirnx, dirny):
        self.dirnx = dirnx
        self.dirny = dirny
        self.pos = (self.pos[0] + self.dirnx, self.pos[1] + self.dirny)

        pass

class snake(object):
    body = []
    turns = {}



    def __init__(self, color, pos):
        self.color = color
        self.head = cube(pos)
        self.body.append(self.head)
        self.dirnx = 0
        self.dirny = 1


        pass

    def move(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()

            keys = pygame.key.get_pressed()

            for key in keys:
                if keys[pygame.K_LEFT]:
                    self.dirnx = -1
                    self.dirny = 0
                    self.turns[self.head.pos[:]] = [self.dirnx, self.dirny]

                elif keys[pygame.K_RIGHT]:
                    self.dirnx = 1
                    self.dirny = 0
                    self.turns[self.head.pos[:]] = [self.dirnx, self.dirny]

                elif keys[pygame.K_UP]:
                    self.dirnx = 0
                    self.dirny = -1
                    self.turns[self.head.pos[:]] = [self.dirnx, self.dirny]

                elif keys[pygame.K_DOWN]:
                    self.dirnx = 0
                    self.dirny = 1
                    self.turns[self.head.pos[:]] = [self.dirnx, self.dirny]
            

        for i, c in enumerate(self.body):
            p = c.pos[:]
            if p in self.turns:
                turn = self.turns[p]
                c.move(turn[0], turn[1])
                if i == len(self.body)-1:
                    self.turns.pop(p)

            else:
                if c.dirnx == -1 and c.pos [0] <= 0: c.pos = (c.rows-1,c.pos[1])
                elif c.dirnx == 1 and c.pos [0] >= c.rows-1: c.pos = (0,c.pos[1])
                elif c.dirny == 1 and c.pos [1] >= c.rows-1: c.pos = (c.pos[0], 0)
                elif c.dirny == -1 and c.pos [1] <= 0: c.pos = (c.pos[0], c.rows-1)
                else: c.move(c.dirnx,c.dirny)
            

        pass
        

    def reset(self, pos):
        pass

    def addCube(self):
        pass
        

    def draw(self, surface):
        for i, c in enumerate(self.body):
            if i == 0:
                c.draw(surface, True)
            else:
                c.draw(surface)    

        pass

def drawGrid(w, rows, surface):
    sizeBtwn = w // rows
    x = 0
    y = 0

    for l in range(rows):

        
        x = x + sizeBtwn
        y = y + sizeBtwn

        pygame.draw.line(surface, (255,255,255), (x,0), (x,w))
        pygame.draw.line(surface, (255,255,255), (0,y), (w,y))

    pass


def redrawWindow(surface):
    global rows, width
    surface.fill((0, 0, 0))
    drawGrid(width, rows, surface)
    pygame.display.update()

    pass



def main():
    
    global width, rows
    width = 500
    rows = 10

    win = pygame.display.set_mode((width, width))

    s = snake((255, 0, 0) , (10, 10))
    flag = True
    clock = pygame.time.Clock()
    while flag:
        pygame.time.delay(50)
        clock.tick(10)
        redrawWindow(win)

    
    pass

if __name__ == "__main__":
    main()

I am getting the following error:

invalid syntax (<unknown>, line 6)

and I have absolutely no idea why. I have looked everywhere, and I can’t find an obvious error. Can anyone see where the error is? Thanks

J

Порой бывает трудно правильно реализовать import с первого раза, особенно если мы хотим добиться правильной работы на плохо совместимых между собой версиях Python 2 и Python 3. Попытаемся разобраться, что из себя представляют импорты в Python и как написать решение, которое подойдёт под обе версии языка.

Содержание

• Ключевые моменты
• Основные определения
• Пример структуры директорий
• Что делает import
• Основы import и sys.path
• Чуть подробнее о sys.path
• Всё о __init__.py
• Использование объектов из импортированного модуля или пакета
• Используем dir() для исследования содержимого импортированного модуля
• Импортирование пакетов
• Абсолютный и относительный импорт
• Примеры
• Python 2 vs Python 3
• Прочие темы, не рассмотренные здесь, но достойные упоминания

Ключевые моменты

• Выражения import производят поиск по списку путей в sys.path.
• sys.path всегда включает в себя путь скрипта, запущенного из командной строки, и не зависит от текущей рабочей директории.
• Импортирование пакета по сути равноценно импортированию  __init__.py этого пакета.

Основные определения

• Модуль: любой файл *.py. Имя модуля — имя этого файла.
• Встроенный модуль: «модуль», который был написан на Си, скомпилирован и встроен в интерпретатор Python, и потому не имеет файла *.py.
• Пакет: любая папка, которая содержит файл __init__.py. Имя пакета — имя папки.
  • С версии Python 3.3 любая папка (даже без __init__.py) считается пакетом.
• Объект: в Python почти всё является объектом — функции, классы, переменные и т. д.

Пример структуры директорий

test/                      # Корневая папка
    packA/                 # Пакет packA
        subA/              # Подпакет subA
            __init__.py
            sa1.py
            sa2.py
        __init__.py
        a1.py
        a2.py
    packB/                 # Пакет packB (неявный пакет пространства имён)
        b1.py
        b2.py
    math.py
    random.py
    other.py
    start.py

Обратите внимание, что в корневой папке test/ нет файла __init__.py.

Что делает import

При импорте модуля Python выполняет весь код в нём. При импорте пакета Python выполняет код в файле пакета __init__.py, если такой имеется. Все объекты, определённые в модуле или __init__.py, становятся доступны импортирующему.

Основы import и sys.path

Вот как оператор import производит поиск нужного модуля или пакета согласно документации Python:

При импорте модуля spam интерпретатор сначала ищёт встроенный модуль с таким именем. Если такого модуля нет, то идёт поиск файла spam.py в списке директорий, определённых в переменной sys.path. sys.path инициализируется из следующих мест:

• директории, содержащей исходный скрипт (или текущей директории, если файл не указан);
• директории по умолчанию, которая зависит от дистрибутива Python;
• PYTHONPATH (список имён директорий; имеет синтаксис, аналогичный переменной окружения PATH).

Программы могут изменять переменную sys.path после её инициализации. Директория, содержащая запускаемый скрипт, помещается в начало поиска перед путём к стандартной библиотеке. Это значит, что скрипты в этой директории будут импортированы вместо модулей с такими же именами в стандартной библиотеке.

Источник: Python 2 и Python 3

Технически документация не совсем полна. Интерпретатор будет искать не только файл (модуль) spam.py, но и папку (пакет) spam.

Обратите внимание, что Python сначала производит поиск среди встроенных модулей — тех, которые встроены непосредственно в интерпретатор. Список встроенных модулей зависит от дистрибутива Python, а найти этот список можно в sys.builtin_module_names (Python 2 и Python 3). Обычно в дистрибутивах есть модули sys (всегда включён в дистрибутив), math, itertools, time и прочие.

В отличие от встроенных модулей, которые при поиске проверяются первыми, остальные (не встроенные) модули стандартной библиотеки проверяются после директории запущенного скрипта. Это приводит к сбивающему с толку поведению: возможно «заменить» некоторые, но не все модули стандартной библиотеки. Допустим, модуль math является встроенным модулем, а random — нет. Таким образом, import math в start.py импортирует модуль из стандартной библиотеки, а не наш файл math.py из той же директории. В то же время, import random в start.py импортирует наш файл random.py.

Кроме того, импорты в Python регистрозависимы: import Spam и import spam — разные вещи.

Функцию pkgutil.iter_modules() (Python 2 и Python 3) можно использовать, чтобы получить список всех модулей, которые можно импортировать из заданного пути:

import pkgutil
search_path = ['.'] # Используйте None, чтобы увидеть все модули, импортируемые из sys.path
all_modules = [x[1] for x in pkgutil.iter_modules(path=search_path)]
print(all_modules)

Чуть подробнее о sys.path

Чтобы увидеть содержимое sys.path, запустите этот код:

import sys
print(sys.path)

Документация Python описывает sys.path так:

Список строк, указывающих пути для поиска модулей. Инициализируется из переменной окружения PYTHONPATH и директории по умолчанию, которая зависит от дистрибутива Python.

При запуске программы после инициализации первым элементом этого списка, path[0], будет директория, содержащая скрипт, который был использован для вызова интерпретатора Python. Если директория скрипта недоступна (например, если интерпретатор был вызван в интерактивном режиме или скрипт считывается из стандартного ввода), то path[0] является пустой строкой. Из-за этого Python сначала ищет модули в текущей директории. Обратите внимание, что директория скрипта вставляется перед путями, взятыми из PYTHONPATH.

Источник: Python 2 и Python 3

Документация к интерфейсу командной строки Python добавляет информацию о запуске скриптов из командной строки. В частности, при запуске python <script>.py.

Если имя скрипта ссылается непосредственно на Python-файл, то директория, содержащая этот файл, добавляется в начало sys.path, а файл выполняется как модуль main.

Источник: Python 2 и Python 3

Итак, повторим порядок, согласно которому Python ищет импортируемые модули:

1. Модули стандартной библиотеки (например, math, os).
2. Модули или пакеты, указанные в sys.path:
   1. 1. Если интерпретатор Python запущен в интерактивном режиме:
         • sys.path[0] — пустая строка ''. Это значит, что Python будет искать в текущей рабочей директории, из которой вы запустили интерпретатор. В Unix-системах эту директорию можно узнать с помощью команды pwd.

         Если мы запускаем скрипт командой python <script>.py:

         • sys.path[0] — это путь к <script>.py.
      2. Директории, указанные в переменной среды PYTHONPATH.
      3. Директория по умолчанию, которая зависит от дистрибутива Python.

Обратите внимание, что при запуске скрипта для sys.path важна не директория, в которой вы находитесь, а путь к самому скрипту. Например, если в командной строке мы находимся в test/folder и запускаем команду python ./packA/subA/subA1.py, то sys.path будет включать в себя test/packA/subA/, но не test/.

Кроме того, sys.path общий для всех импортируемых модулей. Допустим, мы вызвали python start.py. Пусть start.py импортирует packA.a1, а a1.py выводит на экран sys.path. В таком случае sys.path будет включать test/ (путь к start.py), но не test/packA (путь к a1.py). Это значит, что a1.py может вызвать import other, так как other.py находится в test/.

Всё о __init__.py

У файла __init__.py есть две функции:

1. Превратить папку со скриптами в импортируемый пакет модулей (до Python 3.3).
2. Выполнить код инициализации пакета.

Превращение папки со скриптами в импортируемый пакет модулей

Чтобы импортировать модуль (или пакет) из директории, которая находится не в директории нашего скрипта (или не в директории, из которой мы запускаем интерактивный интерпретатор), этот модуль должен быть в пакете.

Как было сказано ранее, любая директория, содержащая файл __init__.py, является пакетом. Например, при работе с Python 2.7 start.py может импортировать пакет packA, но не packB, так как в директории test/packB/ нет файла __init__.py.

Это не относится к Python 3.3 и выше благодаря появлению неявных пакетов пространств имён. Проще говоря, в Python 3.3+ все папки считаются пакетами, поэтому пустые файлы __init__.py больше не нужны.

Допустим, packB — пакет пространства имён, так как в нём нет __init__.py. Если запустить интерактивную оболочку Python 3.6 в директории test/, то мы увидим следующее:

>>> import packB
>>> packB
<module 'packB' (namespace)>

Выполнение кода инициализации пакета

В момент, когда пакет или один из его модулей импортируется в первый раз, Python выполняет __init__.py в корне пакета, если такой файл существует. Все объекты и функции, определённые в __init__.py, считаются частью пространства имён пакета.

Рассмотрим следующий пример:

test/packA/a1.py

def a1_func():
    print("Выполняем a1_func()")

test/packA/__init__.py

## Этот импорт делает функцию a1_func() доступной напрямую из packA.a1_func
from packA.a1 import a1_func

def packA_func():
    print("Выполняем packA_func()")

test/start.py

import packA  # «import packA.a1» сработает точно так же

packA.packA_func()
packA.a1_func()
packA.a1.a1_func()

Вывод после запуска python start.py:

Выполняем packA_func()
Выполняем a1_func()
Выполняем a1_func()

Примечание Если a1.py вызовет import a2, и мы запустим python a1.py, то test/packA/__init__.py не будет вызван, несмотря на то, что a2 вроде бы является частью пакета packA. Это связано с тем, что когда Python выполняет скрипт (в данном случае a1.py), содержащая его папка не считается пакетом.

Использование объектов из импортированного модуля или пакета

Есть 4 разных вида импортов:

1. import <пакет>
2. import <модуль>
3. from <пакет> import <модуль или подпакет или объект>
4. from <модуль> import <объект>

Пусть X — имя того, что идёт после import:

• Если X — имя модуля или пакета, то для того, чтобы использовать объекты, определённые в X, придётся писать X.объект.
• Если X — имя переменной, то её можно использовать напрямую.
• Если X — имя функции, то её можно вызвать с помощью X().

Опционально после любого выражения import X можно добавить as Y. Это переименует X в Y в пределах скрипта. Учтите, что имя X с этого момента становится недействительным. Частым примером такой конструкции является import numpy as np.

Аргументом для import может быть как одно имя, так и их список. Каждое из имён можно переименовать с помощью as. Например, следующее выражение будет действительно в start.py: import packA as pA, packA.a1, packA.subA.sa1 as sa1.

Пример: нужно в start.py импортировать функцию helloWorld() из sa1.py.

• Решение 1: from packA.subA.sa1 import helloWorld. Мы можем вызвать функцию напрямую по имени: x = helloWorld().
• Решение 2: from packA.subA import sa1 или то же самое import packA.subA.sa1 as sa1. Для использования функции нам нужно добавить перед её именем имя модуля: x = sa1.helloWorld(). Иногда такой подход предпочтительнее первого, так как становится ясно, из какого модуля взялась та или иная функция.
• Решение 3: import packA.subA.sa1. Для использования функции перед её именем нужно добавить полный путь: x = packA.subA.sa1.helloWorld().

Прим. перев. После переименования с помощью as новое имя нельзя использовать в качестве имени пакета или модуля для последующих импортов. Иными словами, команда вроде следующей недействительна: import packA as pA, pA.a1.

Используем dir() для исследования содержимого импортированного модуля

После импортирования модуля можно использовать функцию dir() для получения списка доступных в модуле имён. Допустим, мы импортируем sa1. Если в sa1.py есть функция helloWorld(), то dir(sa1) будет включать helloWorld:

>>> from packA.subA import sa1
>>> dir(sa1)
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'helloWorld']

Импортирование пакетов

Импортирование пакета по сути равноценно импортированию его __init__.py. Вот как Python на самом деле видит пакет:

>>> import packA
>>> packA
<module 'packA' from 'packA/__init__.py'>

После импорта становятся доступны только те объекты, что определены в __init__.py пакета. Поскольку в packB нет такого файла, от import packB (в Python 3.3.+) будет мало толку, так как никакие объекты из этого пакета не становятся доступны. Последующий вызов модуля packB.b1 приведёт к ошибке, так как он ещё не был импортирован.

Абсолютный и относительный импорт

При абсолютном импорте используется полный путь (от начала корневой папки проекта) к желаемому модулю.

При относительном импорте используется относительный путь (начиная с пути текущего модуля) к желаемому модулю. Есть два типа относительных импортов:

1. При явном импорте используется формат from .<модуль/пакет> import X, где символы точки . показывают, на сколько директорий «вверх» нужно подняться. Одна точка . показывает текущую директорию, две точки .. — на одну директорию выше и т. д.
2. Неявный относительный импорт пишется так, как если бы текущая директория была частью sys.path. Такой тип импортов поддерживается только в Python 2.

В документации Python об относительных импортах в Python 3 написано следующее:

Единственный приемлемый синтаксис для относительных импортов — from .[модуль] import [имя]. Все импорты, которые начинаются не с точки ., считаются абсолютными.

Источник: What’s New in Python 3.0

В качестве примера допустим, что мы запускаем start.py, который импортирует a1, который импортирует other, a2 и sa1. Тогда импорты в a1.py будут выглядеть следующим образом:

Абсолютные импорты:

import other
import packA.a2
import packA.subA.sa1

Явные относительные импорты:

import other
from . import a2
from .subA import sa1

Неявные относительные импорты (не поддерживаются в Python 3):

import other
import a2
import subA.sa1

Учтите, что в относительных импортах с помощью точек . можно дойти только до директории, содержащей запущенный из командной строки скрипт (не включительно). Таким образом, from .. import other не сработает в a1.py. В результате мы получим ошибку ValueError: attempted relative import beyond top-level package.

Как правило, абсолютные импорты предпочтительнее относительных. Они позволяют избежать путаницы между явными и неявными импортами. Кроме того, любой скрипт с явными относительными импортами нельзя запустить напрямую:

Имейте в виду, что относительные импорты основаны на имени текущего модуля. Так как имя главного модуля всегда "__main__", модули, которые должны использоваться как главный модуль приложения, должны всегда использовать абсолютные импорты.

Источник: Python 2 и Python 3

Примеры

Пример 1: sys.path известен заранее

Если вы собираетесь вызывать только python start.py или python other.py, то прописать импорты всем модулям не составит труда. В данном случае sys.path всегда будет включать папку test/. Таким образом, все импорты можно писать относительно этой папки.

Пример: файлу в проекте test нужно импортировать функцию helloWorld() из sa1.py.

Решение: from packA.subA.sa1 import helloWorld (или любой другой эквивалентный синтаксис импорта).

Пример 2: sys.path мог измениться

Зачастую нам требуется как запускать скрипт напрямую из командной строки, так и импортировать его как модуль в другом скрипте. Как вы увидите далее, здесь могут возникнуть проблемы, особенно в Python 3.

Пример: пусть start.py нужно импортировать a2, которому нужно импортировать sa2. Предположим, что start.py всегда запускается напрямую, а не импортируется. Также мы хотим иметь возможность запускать a2 напрямую.

Звучит просто, не так ли? Нам всего лишь нужно выполнить два импорта: один в start.py и другой в a2.py.

Проблема: это один из тех случаев, когда sys.path меняется. Когда мы выполняем start.py, sys.path содержит test/, а при выполнении a2.py sys.path содержит test/packA/.

С импортом в start.py нет никаких проблем. Так как этот модуль всегда запускается напрямую, мы знаем, что при его выполнении в sys.path всегда будет test/. Тогда импортировать a2 можно просто с помощью import packA.a2.

С импортом в a2.py немного сложнее. Когда мы запускаем start.py напрямую, sys.path содержит test/, поэтому в a2.py импорт будет выглядеть как from packA.subA import sa2. Однако если запустить a2.py напрямую, то в sys.path уже будет test/packA/. Теперь импорт вызовет ошибку, так как packA не является папкой внутри test/packA/.

Вместо этого мы могли бы попробовать from subA import sa2. Это решает проблему при запуске a2.py напрямую, однако теперь создаёт проблему при запуске start.py. В Python 3 это приведёт к ошибке, потому что subA не находится в sys.path (в Python 2 это не вызовет проблемы из-за поддержки неявных относительных импортов).

Обобщим информацию:

Использование относительного импорта from .subA import sa2 будет иметь тот же эффект, что и from packA.subA import sa2.

Вряд ли для этой проблемы есть чистое решение, поэтому вот несколько обходных путей:

1. Использовать абсолютные импорты относительно директории test/ (т. е. средняя колонка в таблице выше). Это гарантирует, что запуск start.py напрямую всегда сработает. Чтобы запустить a2.py напрямую, запустите его как импортируемый модуль, а не как скрипт:

1. В консоли смените директорию на  test/.
2. Запустите python -m packA.a2.

2. Использовать абсолютные импорты относительно директории test/ (средняя колонка в таблице). Это гарантирует, что запуск start.py напрямую всегда сработает. Чтобы запустить a2.py напрямую, можно изменить sys.path в a2.py, чтобы включить test/packA/ перед импортом sa2.

import os, sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))

# Теперь это сработает даже если a2.py будет запущен напрямую
from packA.subA import sa2

Примечание Обычно этот метод работает, однако в некоторых случаях переменная __file__ может быть неправильной. В таком случае нужно использовать встроенный пакет inspect. Подробнее в этом ответе на StackOverflow.

3. Использовать только Python 2 и неявные относительные импорты (последняя колонка в таблице).

4. Использовать абсолютные импорты относительно директории test/ и добавить её в переменную среды PYTHONPATH. Это решение не переносимо, поэтому лучше не использовать его. О том, как добавить директорию в PYTHONPATH, читайте в этом ответе.

Пример 3: sys.path мог измениться (вариант 2)

А вот ещё одна проблема посложнее. Допустим, модуль a2.py никогда не надо запускать напрямую, но он импортируется start.py и a1.py, которые запускаются напрямую.

В этом случае первое решение из примера выше не сработает. Тем не менее, всё ещё можно использовать остальные решения.

Пример 4: импорт из родительской директории

Если мы не изменяем PYTHONPATH и стараемся не изменять sys.path программно, то сталкиваемся со следующим основным ограничением импортов в Python: при запуске скрипта напрямую невозможно импортировать что-либо из его родительской директории.

Например, если бы нам пришлось запустить python sa1.py, то этот модуль не смог бы ничего импортировать из a1.py без вмешательства в PYTHONPATH или sys.path.

На первый взгляд может показаться, что относительные импорты (например from .. import a1) помогут решить эту проблему. Однако запускаемый скрипт (в данном случае sa1.py) считается «модулем верхнего уровня». Попытка импортировать что-либо из директории над этим скриптом приведёт к ошибке ValueError: attempted relative import beyond top-level package.

Для решения этой проблемы лучше её не создавать и избегать написания скриптов, которые импортируют из родительской директории. Если этого нельзя избежать, то предпочтительным обходным путём является изменение sys.path.

Python 2 vs Python 3

Мы разобрали основные отличия импортов в Python 2 и Python 3. Они ещё раз изложены здесь наряду с менее важными отличиями:

1. Python 2 поддерживает неявные относительные импорты, Python 3 — нет.
2. В Python 2, чтобы папка считалась пакетом и её можно было импортировать, она должна содержать файл __init__.py. С версии Python 3.3 благодаря введению неявных пакетов пространств имён все папки считаются пакетами вне зависимости от наличия __init__.py.
3. В Python 2 можно написать from <модуль> import * внутри функции, а в Python 3 — только на уровне модуля.

Ещё немного полезной информации по импортам

• Можно использовать переменную __all__ в __init__.py, чтобы указать, что будет импортировано выражением from <модуль> import *. Смотрите документацию для Python 2 и Python 3.
• Можно использовать if __name__ == '__main__' для проверки, был ли скрипт импортирован или запущен напрямую. Документация для Python 2 и Python 3.
• Можно установить проект в качестве пакета (в режиме разработчика) с помощью pip install -e <проект>, чтобы добавить корень проекта в sys.path. Подробнее в этом ответе на StackOverflow.
• from <модуль> import * не импортирует имена из модуля, которые начинаются с нижнего подчеркивания _. Подробнее читайте в документации Python 2 и Python 3.

Перевод статьи «The Definitive Guide to Python import Statements»