我收到一个缩进错误.我如何解决它? [英] I'm getting an IndentationError. How do I fix it?

问题描述

我有一个 Python 脚本:

如果为真:如果为假:打印('富')打印('条')

但是，当我尝试运行我的脚本时，Python 会引发 IndentationError:

 文件script.py"，第 4 行打印('条')^IndentationError: unindent 不匹配任何外部缩进级别

我一直在玩我的程序，我还能够产生其他四个错误:

• IndentationError:意外缩进
• IndentationError:需要一个缩进块
• IndentationError: unindent 不匹配任何外部缩进级别
• TabError:在缩进中使用制表符和空格不一致

这些错误是什么意思?我究竟做错了什么?如何修复我的代码?

解决方案

为什么缩进很重要?

在 Python 中，缩进用于分隔

我们可以看到我们确实混合了空格和制表符来缩进.

特殊情况

注意 Python 不会 总是在程序中混用制表符和空格时引发TabError.如果程序缩进是明确的，Python 将允许混合使用制表符和空格.例如:

<预><代码>>>>如果是真的:... 如果为真:# 选项卡...传递 # 制表符，然后是 4 个空格...>>>

有时 Python 会因制表符和空格的混合而窒息，并在 TabError 更合适时错误地引发 IndentationError 异常.另一个例子:

<预><代码>>>>如果是真的:...通过#标签...传递 # 4 个空格文件

如您所见，以这种方式运行代码会产生神秘的错误.尽管该程序视觉看起来不错，但 Python 在尝试解析用于缩进的制表符和空格时变得困惑并出错.

这些很好的例子说明了为什么在使用 Python 2 时永远不要混合制表符和空格并使用 -t 和 -tt 解释器标志.

修复

如果您的程序很短，可能最简单快捷的解决方法就是简单地重新缩进程序.确保每个语句在每个缩进级别缩进四个空格(请参阅如何缩进我的代码?).

但是，如果您已经有一个混合制表符和空格的大型程序，则可以使用自动化工具将所有缩进转换为空格.

许多编辑器，例如 PyCharm 和 SublimeText 有自动将制表符转换为空格的选项.还有一些在线工具，例如 Tabs To Spaces 或 浏览 允许您快速重新缩进代码.也有用 Python 编写的工具.autopep8 例如可以自动重新缩进您的代码并修复其他缩进错误.

即使是最好的工具有时也无法修复所有缩进错误，您必须手动修复它们.这就是为什么从一开始就正确缩进代码很重要.

关于SyntaxError"的说明；相关缩进问题

虽然不常见，但有时会由于不正确的缩进而引发某些 SyntaxError 异常.例如，看下面的代码:

如果为真:经过通过# 哎呀！这个语句应该缩进！.别的:经过

当上面的代码运行时，会引发一个SyntaxError:

回溯(最近一次调用最后一次):文件python"，第 4 行别的:^语法错误:无效语法

尽管 Python 引发了 SyntaxError，但上述代码的真正问题是第二个 pass 语句应该缩进.因为第二个 pass 没有缩进，Python 没有意识到前面的 if 语句和 else 语句是要连接的.

修复此类错误的方法是简单地正确地重新缩进您的代码.要了解如何正确缩进代码，请参阅如何缩进代码?部分.

我仍然很难使用 Python 的缩进语法.我该怎么办?

如果你还在挣扎，不要气馁.可能需要时间来适应Python 的空格语法规则.以下是一些有用的提示:

• 获取一个编辑器，当您遇到缩进错误时会告诉您.一些商品如上所说，PyCharm、SublimeText 和 Jupyter Notebook.莉>
• 当您缩进代码时，请自己大声计算您按空格键(或 Tab 键)的次数.例如，如果您需要将一行缩进四个空格，您可以大声说one, two, three, 四个"每次同时按下空格键.这听起来很傻，但它有助于训练您的大脑思考代码缩进的深度.
• 如果您有编辑器，请查看它是否具有自动将制表符转换为空格的选项.
• 查看其他人的代码.浏览 github 或 Stackoverflow 并查看示例的 Python 代码.
• 只需编写代码.这是变得更好的唯一最好方法.你编写的 Python 代码越多，你就会得到越好.

使用的资源

• https://en.wikipedia.org/
• https://docs.python.org/3/
• http://python-history.blogspot.com/2009/02/early-language-design-and-development.html
• https://www.python.org/dev/peps/pep-0008/

I have a Python script:

if True:
    if False:
        print('foo')
   print('bar')

However, when I attempt to run my script, Python raises an IndentationError:

  File "script.py", line 4
    print('bar')
               ^
IndentationError: unindent does not match any outer indentation level

I kept playing around with my program, and I was also able to produce four other errors:

• IndentationError: unexpected indent
• IndentationError: expected an indented block
• IndentationError: unindent does not match any outer indentation level
• TabError: inconsistent use of tabs and spaces in indentation

What do these errors mean? What am I doing wrong? How can I fix my code?

解决方案

Why does indentation matter?

In Python, indentation is used to delimit blocks of code. This is different from many other languages that use curly braces {} to delimit blocks such as Java, Javascript, and C. Because of this, Python users must pay close attention to when and how they indent their code because whitespace matters.

When Python encounters a problem with the indentation of your program, it either raises an exception called IndentationError or TabError.

A little history

The historical reasons for why Python uses indentation vs the arguably more commonly accepted curly braces {} is outlined in an article of the history of Python by Guido van Rossum - the creator of Python:

Python’s use of indentation comes directly from ABC, but this idea didn’t originate with ABC--it had already been promoted by Donald Knuth and was a well-known concept of programming style. (The occam programming language also used it.) However, ABC’s authors did invent the use of the colon that separates the lead-in clause from the indented block. After early user testing without the colon, it was discovered that the meaning of the indentation was unclear to beginners being taught the first steps of programming. The addition of the colon clarified it significantly: the colon somehow draws attention to what follows and ties the phrases before and after it together in just the right way.

How do I indent my code?

The basic rule for indenting Python code (considering that you treat the entire program as a "basic block") is: The first statement in a basic block, and each subsequent statement after it must be indented by the same amount.

So technically the following Python program is correct:

def perm(l):
        # Compute the list of all permutations of l
    if len(l) <= 1:
                  return [l]
    r = []
    for i in range(len(l)):
             s = l[:i] + l[i+1:]
             p = perm(s)
             for x in p:
              r.append(l[i:i+1] + x)
    return r

However, as you can probably tell from above, randomly indenting your code makes is extremely hard to read and follow the flow of the program. It's better to be consistent and follow a style.

PEP8 - The Python style guide - recommends that four spaces per indentation level should be used:

Use 4 spaces per indentation level.

That is, each statement that is starting a new block and each subsequent statement in the new block, should be indented four spaces from the current indentation level. Here is the above program indented according to the PEP8 style guide:

def perm(l):
    # Compute the list of all permutations of l
    if len(l) <= 1:
        return [l]
    r = []
    for i in range(len(l)):
        s = l[:i] + l[i+1:]
        p = perm(s)
        for x in p:
            r.append(l[i:i+1] + x)
    return r

Can I still use tabs?

Python realizes that some people still prefer tabs over spaces and that legacy code may use tabs rather than spaces, so it allows the use of tabs as indentation. PEP8 touches on this topic:

Spaces are the preferred indentation method.

Tabs should be used solely to remain consistent with code that is already indented with tabs.

Note however the one big caveat is not to use both tabs and spaces for indentation. Doing so can cause all kinds of strange hard to debug indentation errors. Python expands tabs to the next 8th column, but if your editor is set to a tab size of 4 columns, or you you use spaces as well as tabs, you can easily produce indented code that looks fine in your editor, but Python will refuse to run. The Python 3 compiler explicitly rejects any program containing an ambiguous mixture of tabs and spaces, usually by raising a TabError. However, by default, mixing tabs and spaces is still allowed in Python 2, but it is highly recommended not to use this "feature". Use the -t and -tt command line flags to force Python 2 to raise a warning or (preferably) an error respectively. PEP8 also discusses this topic:

Python 3 disallows mixing the use of tabs and spaces for indentation.

Python 2 code indented with a mixture of tabs and spaces should be converted to using spaces exclusively.

When invoking the Python 2 command line interpreter with the -t option, it issues warnings about code that illegally mixes tabs and spaces. When using -tt these warnings become errors. These options are highly recommended!

What does "IndentationError: unexpected indent" mean?

Problem

This error occurs when a statement is unnecessarily indented or its indentation does not match the indentation of former statements in the same block. For example, the first statement in the program below is unnecessarily indented:

>>>  print('Hello') # this is indented 
  File "<stdin>", line 1
    print('Hello') # this is indented 
    ^
IndentationError: unexpected indent

In this example, the can_drive = True line in the if block does not match the indentation of any former statement:

>>> age = 10
>>> can_drive = None
>>> 
>>> if age >= 18:
...     print('You can drive')
...      can_drive = True # incorrectly indented
  File "<stdin>", line 3
    can_drive = True # incorrectly indented
    ^
IndentationError: unexpected indent

Fix

The fix for this error is to first make sure the problematic line even needs to be indented. For example, the above example using print can be fixed simply be unindenting the line:

>>> print('Hello') # simply unindent the line
Hello

However, if you are sure the line does need to be indented, the indentation needs to match that of a former statement in the same block. In the second example above using if, we can fix the error by making sure the line with can_drive = True is indented at the same level as the former statements in the if body:

>>> age = 10
>>> can_drive = None
>>> 
>>> if age >= 18:
...     print('You can drive')
...     can_drive = True # indent this line at the same level.
... 

What does "IndentationError: expected an indented block" mean?

Problem

This error occurs when Python sees the 'header' for a compound statement, such as if <condition>: or while <condition>: but the compound statement's body or block is never defined. For example in the code below we began an if statement, but we never define a body for the statement:

>>> if True:
... 
  File "<stdin>", line 2
    
    ^
IndentationError: expected an indented block

In this second example, we began writing a for loop, but we forget to indent the for loop body. So Python still expects an indented block for the for loop body:

>>> names = ['sarah', 'lucy', 'michael']
>>> for name in names:
... print(name)
  File "<stdin>", line 2
    print(name)
        ^
IndentationError: expected an indented block

Comments don't count as bodies:

>>> if True:
...     # TODO
...
  File "<stdin>", line 3

    ^
IndentationError: expected an indented block

Fix

The fix for this error is to simply include a body for the compound statement.

As shown above, a common mistake by new users is that they forget to indent the body. If this is the case, make sure each statement meant to be included in the compound statement's body is indented at the same level under the compound statement's beginning. Here is the above example fixed:

>>> names = ['sarah', 'lucy', 'michael']
>>> for name in names:
...     print(name) # The for loop body is now correctly indented.
... 
sarah
lucy
michael

Another common case is that, for some reason, a user may not want to define an actual body for the compound statement, or the body may be commented out. In this case, the pass statement can be used. The pass statement can be used anywhere Python expects one or more statements as a placeholder. From the documentation for pass:

pass is a null operation — when it is executed, nothing happens. It is useful as a placeholder when a statement is required syntactically, but no code needs to be executed, for example:

def f(arg): pass    # a function that does nothing (yet)

class C: pass       # a class with no methods (yet)

Here is the above example with the if statement fixed by using the pass keyword:

>>> if True:
...     pass # We don't want to define a body.
... 
>>>

What does "IndentationError: unindent does not match any outer indentation level" mean?

Problem

This error occurs when you unindent a statement, but now the indentation level of that statement does not match that of any former statement. For example, in the below code we unindent the second call to print. However, the indentation level does not match that of any former statement:

>>> if True:
...     if True:
...         print('yes')
...    print()
  File "<stdin>", line 4
    print()
          ^
IndentationError: unindent does not match any outer indentation level

This error is especially hard to catch because even one space will cause your code to fail.

Fix

The fix is to ensure that when you unindent a statement, the indentation level matches that of a former statement. Consider the above example once again. In the example, I want the second call to print to be in the first if statements body. So I need to make sure that that line's indentation level matches that of the former statements in the first if statement's body:

>>> if True:
...     if True:
...         print('yes')
...     print() # indentation level now matches former statement's level.
... 
yes

>>> 

I'm still getting an IndentationError but my program appears to be correctly indented. What do I do?

If your program visually appears to have correct indentation, but your still getting an IndentationError you have most likely mixed tabs with spaces. This will sometimes cause Python to raises strange errors. See the subsection Special cases under What does "TabError: inconsistent use of tabs and spaces in indentation" mean? for an more in-depth explanation of the problem.

What does "TabError: inconsistent use of tabs and spaces in indentation" mean?

Problem

This error only occurs when you attempt to mix tabs and spaces as indentation characters. As said above, Python will not allow your program to contain a mix of tabs and spaces, and will raise the specific exception TabError if it finds you have. For example, in the program below, a mix of tabs and spaces is used for indentation:

>>> if True:
...     if True:
...         print()
...     print()
...     print()
  File "<stdin>", line 5
    print()
          ^
TabError: inconsistent use of tabs and spaces in indentation

Here is a picture which visually shows the whitespace in the above program. Gray dots are spaces, and gray arrows are tabs:

We can see we have indeed mixed spaces and tabs for indentation.

Special cases

Note Python will not always raise a TabError if you mix tabs and spaces into your program. If the program indentation is unambiguous, Python will allow tabs and spaces to be mixed. For example:

>>> if True:
...     if True: # tab
...         pass # tab, then 4 spaces
... 
>>>

And sometimes Python simply chokes on the mixture of tabs and spaces and erroneously raises an IndentationError exception when a TabError would be more appropriate. Another example:

>>> if True:
...     pass # tab
...     pass # 4 spaces
  File "<stdin>", line 3
    pass # 4 spaces
                ^
IndentationError: unindent does not match any outer indentation level

As you can see, running your code this way can create mysterious errors. Even though the program visually appears to be fine, Python became confused trying to parse the tabs and spaces used for indention and errored out.

These are excellent examples that demonstrate why to never mix tabs and spaces and make use of the -t and -tt interpreter flags when using Python 2.

Fix

If your program is short, probably the easiest and quickest fix is to simply re-indent the program. Make sure each statement is indented by four spaces per indention level (see How do I indent my code?).

However, if you already have a large program that you've mixed tabs and spaces into, there are automated tools that can be used to convert all of your indentation to just spaces.

Many editors such as PyCharm and SublimeText have options to automatically convert tabs to spaces. There are also several on-line tools such as Tabs To Spaces or Browserling that allow you to quickly re-indent your code. There are also tools written in Python. autopep8 for example can automatically re-indent your code and fix other indentation errors as well.

Even the best tools though will sometimes not be able to fix all of your indentation errors and you'll have to fix them manually. That's why it's important to always properly indent your code from the start.

A note about "SyntaxError" related indentation problems

Although not often, sometimes certain SyntaxError exceptions are raised due to incorrect indentation. For example, look at the code below:

if True:
    pass
pass # oops! this statement should be indented!.
else:
    pass

When the above code is run, a SyntaxError is raised:

Traceback (most recent call last):
  File "python", line 4
    else:
       ^
SyntaxError: invalid syntax

Although Python raises a SyntaxError, the real problem with the above code, is that the second pass statement should be indented. Because the second pass isn't indented, Python doesn't realize that the previous if statement and the else statement are meant to be connected.

The fix for this type of error is to simply correctly re-indent your code. To see how to properly indent your code, see the section How do I indent my code?.

I'm still having a hard time with Python's indentation syntax. What do I do?

Don't get discouraged if you're still struggling. It can take time to get use to Python's whitespace syntax rules. Here are some tips to help:

• Get an editor that will tell you when you have an indentation error. Some goods ones are as said above are, PyCharm, SublimeText, and Jupyter Notebook.
• When you indent your code, count out loud to yourself how many times you press the space-bar (or tab key). For example, if you needed to indent a line by four spaces, you would say out loud "one, two, three, four" while simultaneously pressing the space-bar each time. It sounds silly, but it helps train your brain to think about how deep you're indenting your code.
• If you have an editor, see if it has an option to automatically convert tabs to spaces.
• View others' code. Browse github or Stackoverflow and see examples of Python code.
• Just write code. That's the single best way to get better. The more you write Python code, the better you'll get.

Resources used

• https://en.wikipedia.org/
• https://docs.python.org/3/
• http://python-history.blogspot.com/2009/02/early-language-design-and-development.html
• https://www.python.org/dev/peps/pep-0008/

这篇关于我收到一个缩进错误.我如何解决它?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！