如何使用“pass”语句？

问题描述：

我正在学习 Python，已经到了关于该pass语句的部分。我使用的指南将其定义为通常用作占位符的空语句。

但我还是不完全理解这是什么意思。在什么简单/基本情况下pass会用到该语句，为什么需要它？

解决方案 1：

假设您正在设计一个新类，其中包含一些您还不想实现的方法。

class MyClass(object):
    def meth_a(self):
        pass

    def meth_b(self):
        print "I'm meth_b"

如果您省略pass，代码将无法运行。

然后你会得到：

IndentationError: expected an indented block

总而言之，该pass语句没有什么特别之处，但它可以充当占位符，如此处所示。

解决方案 2：

Python 的语法要求是代码块（在if、except、等之后）def不能class为空。然而，空代码块在各种不同的上下文中都很有用，例如下面的示例，这是我见过的最常见的用例。

因此，如果代码块中什么都不发生，则pass需要 才能使这样的代码块不产生IndentationError。或者，可以使用任何语句（包括要评估的术语，如Ellipsis文字...或字符串，通常是文档字符串），但pass明确表示实际上什么都不发生，并且不需要实际评估并（至少暂时）存储在内存中。

• 忽略（全部或）某种类型的Exception（示例来自xml）：

 try:
     self.version = "Expat %d.%d.%d" % expat.version_info
 except AttributeError:
     pass # unknown

注意：忽略所有类型的引发，如下面的示例所示pandas，通常被认为是不好的做法，因为它还会捕获可能应该传递给调用者的异常，例如KeyboardInterrupt或SystemExit（甚至HardwareIsOnFireError- 您如何知道您没有在定义了特定错误的自定义框上运行，某些调用应用程序想要了解这些错误？）。

 try:
     os.unlink(filename_larry)
 except:
     pass

相反，使用至少except Error:或在这种情况下最好except OSError:被认为是更好的做法。对我安装的所有 Python 模块的快速分析表明，超过 10% 的except ...: pass语句会捕获所有异常，因此这仍然是 Python 编程中的常见模式。

• 派生不添加新行为的异常类（例如在SciPy中）：

 class CompileError(Exception):
     pass

类似地，旨在作为抽象基类的类通常具有显式空__init__方法或其他方法，子类应该派生这些方法（例如pebl）：

 class _BaseSubmittingController(_BaseController):
     def submit(self, tasks): pass
     def retrieve(self, deferred_results): pass

• 测试代码是否能通过几个测试值正常运行，而不关心结果（来自mpmath）：

 for x, error in MDNewton(mp, f, (1,-2), verbose=0,
                          norm=lambda x: norm(x, inf)):
     pass

• 在类或函数定义中，通常已经存在文档字符串作为块中唯一要执行的强制语句。在这种情况下，块可能pass 除了文档字符串之外还包含其他内容，以表明“这确实不打算执行任何操作”，例如pebl：

 class ParsingError(Exception):
     """Error encountered while parsing an ill-formed datafile."""
     pass

• 在某些情况下，pass用作占位符来表示“此方法/类/ if-block / ...尚未实现，但这是执行它的地方”，尽管我个人更喜欢Ellipsis文字...，以便严格区分此文字和上例中故意的“无操作”。 （请注意，省略号文字仅在 Python 3 中才是有效表达式）

例如，如果我粗略地写一个模型，我可能会写

 def update_agent(agent):
     ...

其他人可能

 def update_agent(agent):
     pass

前

 def time_step(agents):
     for agent in agents:
         update_agent(agent)

update_agent作为提醒，稍后再填写该函数，但已运行一些测试以查看其余代码是否按预期运行。 （这种情况的第三个选项是raise NotImplementedError。这在两种情况下特别有用：要么“此抽象方法应由每个子类实现，并且在此基类中没有通用方法来定义它”，要么“此函数，此名称，尚未在此版本中实现，但它的签名将是这样的”）

解决方案 3：

除了用作未实现函数的占位符之外，pass它还有助于填写 if-else 语句（“显式优于隐式。”）。

def some_silly_transform(n):
    # Even numbers should be divided by 2
    if n % 2 == 0:
        n /= 2
        flag = True
    # Negative odd numbers should return their absolute value
    elif n < 0:
        n = -n
        flag = True
    # Otherwise, number should remain unchanged
    else:
        pass

当然，在这种情况下，人们可能会使用return它而不是赋值，但是在需要变异的情况下，这种方法最有效。

此处的使用pass尤其有用，可以警告未来的维护者（包括您自己！）不要将多余的步骤放在条件语句之外。在上面的例子中，flag在两个特别提到的案例中设置，但在else-case 中不设置。如果不使用pass，未来的程序员可能会移至flag = True条件之外——从而flag在所有情况下都设置。

另一种情况是文件底部经常看到的样板函数：

if __name__ == "__main__":
    pass

在某些文件中，最好将其保留在那里，pass以便以后更轻松地进行编辑，并明确表示在文件自行运行时不会发生任何事情。

最后，正如其他答案中提到的，捕获到异常时不执行任何操作可能会很有用：

try:
    n[i] = 0
except IndexError:
    pass

解决方案 4：

最好和最准确的思考方式pass是明确地告诉解释器什么都不做。以同样的方式，以下代码：

def foo(x,y):
    return x+y

意思是“如果我调用函数 foo(x, y)，将标签 x 和 y 所代表的两个数字相加并返回结果”，

def bar():
    pass

意思是“如果我调用函数 bar()，则什么也不做。”

其他答案都非常正确，但对于一些不涉及占位的事情它也很有用。

例如，在我最近编写的一段代码中，需要除以两个变量，并且除数可能为零。

c = a / b

如果 b 为零，显然会产生 ZeroDivisionError。在这种特殊情况下，如果 b 为零，则将 c 保留为零是理想的行为，因此我使用了以下代码：

try:
    c = a / b
except ZeroDivisionError:
    pass

另一个不太标准的用法是将其作为放置调试器断点的方便位置。例如，我希望在 for...in 语句的第 20 次迭代时将一些代码中断到调试器中。因此：

for t in range(25):
    do_a_thing(t)
    if t == 20:
        pass

断点已通过。

解决方案 5：

可以“按原样”使用它的一个常见用例是覆盖一个类以创建一个类型（与超类相同），例如

class Error(Exception):
    pass

因此你可以引发并捕获Error异常。这里重要的是异常的类型，而不是内容。

解决方案 6：

你可以说pass意味着一个NOP（无操作）操作。看完这个例子你就会明白：

C 程序

#include<stdio.h>

void main()
{
    int age = 12;
  
    if( age < 18 )
    {
         printf("You are not adult, so you can't do that task ");
    }
    else if( age >= 18 && age < 60)
    {
        // I will add more code later inside it 
    }
    else
    {
         printf("You are too old to do anything , sorry ");
    }
}

现在用 Python 来写这个代码：

age = 12

if age < 18:

    print "You are not adult, so you can't do that task"

elif age >= 18 and age < 60:

else:

    print "You are too old to do anything , sorry "

但是你的代码会报错，因为它需要在elif后面有一个缩进的块。这就是pass关键字的作用。

age = 12

if age < 18:

    print "You are not adult, so you can't do that task"

elif age >= 18 and age < 60:
    
    pass

else:

    print "You are too old to do anything , sorry "

现在我想你已经清楚了。

解决方案 7：

pass在 Python 中基本上不执行任何操作，但与注释不同，它不会被解释器忽略。因此，你可以在很多地方利用它，将其设为占位符：

1：可在课堂上使用

class TestClass:
    pass

2：可以在循环和条件语句中使用：

if (something == true):  # used in conditional statement
    pass

while (some condition is true):  # user is not sure about the body of the loop
    pass

3：可在函数中使用：

def testFunction(args): # The programmer wants to implement the body of the function later
    pass

pass主要用于程序员暂时不想给出实现，但仍想创建某个类/函数/条件语句以供以后使用的情况。由于 Python 解释器不允许空白或未实现的类、函数或条件语句，因此它会给出错误：

IndentationError：预期一个缩进的块

pass可以在这样的场景中使用。

解决方案 8：

老实说，我认为官方 Python 文档对此描述得很好并提供了一些示例：

pass语句不执行任何操作。当语法上需要语句但程序不需要任何操作时，可以使用它。例如：

`>>> while True:
... pass # Busy-wait for keyboard interrupt (Ctrl+C)
...`

这通常用于创建最小类：

`>>> class MyEmptyClass:
... pass
...`

另一个可以使用pass的地方是，当你在处理新代码时，它可以作为函数或条件体的占位符，让你能够继续在更抽象的层面上思考。pass会被默默忽略：

`>>> def initlog(*args):
... pass # Remember to implement this!
...`

解决方案 9：

如果您想导入一个模块（如果它存在）并忽略导入它（如果该模块不存在），您可以使用以下代码：

try:
    import a_module
except ImportError:
    pass
# The rest of your code

如果您避免编写pass语句并继续编写其余代码，则会引发 IndentationError，因为打开 except 块后的行没有缩进。

解决方案 10：

正如书中所说，我只将它用作临时占位符，即

# code that does something to to a variable, var
if var == 2000:
    pass
else:
    var += 1

然后稍后填写场景var == 2000。

解决方案 11：

除了“我不想在这里放任何东西”的“主要”用法之外，这里是我刚刚发现的一个，假设gen是Iterator：

i = 0
obj = None

for i, obj in enumerate(gen):
    pass

这将一次性获取 的最后一个对象yieldedgen和 的长度。（仔细想想，这有点类似于 C 语言中以分号结尾的循环。）gen`while`

解决方案 12：

当您编写代码来设计游戏或类似的东西时，Pass通常很有用，现在，当您继续执行代码时，您会意识到，有些函数您不想继续执行，而想将其保持不变，继续执行代码，然后稍后再重新访问该函数，但是当您这样做时，编译器显然会抛出一个错误，说它无法识别以及各种其他事情！！在这种情况下，您使用pass，这样编译器就会忽略该函数并继续执行代码！！

例如 -

if __name__ = "__main__":
pass
print("Hello World!")

这里编译器会忽略 if name 部分并按照指示打印 Hello World !!

谢谢 ！

解决方案 13：

首先，如果你想写一个块，像这样：

if statement:
    pass
for i in range(abc):
    pass
def func():
    pass

并且pass可以作为占位符。

其次，它可以让你与 IDE 进行“交流”：当你想让你的 IDE 像这样减少缩进时：

如果你的程序写在这里：

class abc(parent):
    def __init__(self, params):
        self.params=params
        if d:
            return
        else:
            return
        # cursor in there

现在你的缩进数是 2，但你希望下一行的缩进数是 1。你可以输入pass，你的程序将是这样的：

class abc(parent):
    def __init__(self, params):
        self.params=params
        if d:
            return
        else:
            return
        pass# cursor in there

然后返回。它会让你开心：

class abc(parent):
    def __init__(self, params):
        self.params=params
        if d:
            return
        else:
            return
        pass
    # cursor in there

现在缩进数为 1。

解决方案 14：

pass只是空虚的 指示 代码.

例如，pass用于创建一个空类或函数，如下所示：

class Test:
    pass

def test():
    pass

但是，如果一个类或函数实际上什么都没有，甚至pass如下所示：

class Test:
    # pass

def test():
    # psss

出现错误如下图所示：

SyntaxError：解析时出现意外的 EOF

而且正如我之前所说，pass只是空的指示代码，所以如果后面有一些代码pass，代码的工作方式如下所示：

class Test:
    pass
    x = "Hello World"

def test():
    pass
    return "Hello World"

print(Test.x) # Hello World
print(test()) # Hello World

解决方案 15：

我简要地看了一下答案，没有看到我使用pass的案例。我有一个串行设备，它接受具有以下结构的相同长度的帧：

| start | command | data ... | check sum |

其中每个 sell 都是一个字节。然后我有以下装饰器来做一些常见的工作并包装特定的命令（见下文）：

def _send_command(c: ECommand) :
    def inner(fillCommand) :
        def wrapper(self, *args, **kwargs) :
            self._reset()
            fillCommand(self, *args, **kwargs) # specific command
            self._command[0] = TemperatureMonitor.FRAME_START
            self._command[1] = c
            self._command[-1] = sum(self._command[:-1]) % 0x100
            self._send(self._command)
        return wrapper
    return inner

然后，为了发送一些特定的命令，我为其定义了一个成员函数：

@_send_command(c = ECommand.ADDRESS)
def readAddress(self, n: int) -> None :
    self._command[2] = n

问题是有些命令本身不应该做任何额外的工作（就像self._command[2] = n前面的代码片段一样）——包装器会做所有事情。所以在这种情况下，成员函数如下所示：

@_send_command(c = ECommand.NUMBER)
def readNumberOfSensors(self) :
    pass

解决方案 16：

当语法上需要一个语句，但又不想执行任何命令或代码时，使用 Python 中的 pass 语句。

pass 语句是空操作；执行时不会发生任何事情。pass 还可用于代码最终会用到但尚未编写的地方（例如，在存根中）：

例子：

#!/usr/bin/python

for letter in 'Python':
   if letter == 'h':
      pass
      print 'This is pass block'
   print 'Current Letter :', letter

print "Good bye!"

这将产生以下结果：

Current Letter : P
Current Letter : y
Current Letter : t
This is pass block
Current Letter : h
Current Letter : o
Current Letter : n
Good bye!

如果字母的值为“h”，则上述代码不会执行任何语句或代码。创建代码块后，pass 语句很有用，但不再需要它。

然后，您可以删除块内的语句，但让块保留 pass 语句，以便它不会干扰代码的其他部分。

解决方案 17：

Pass 指的是忽略...就这么简单。如果给定的条件为真，并且下一个语句是pass，它会忽略该值或迭代并继续下一行。

例子：

for i in range (1, 100):
    if i%2 == 0:
        pass
    else:
        print(i)

输出：打印 1-100 之间的所有奇数

这是因为偶数的模数等于零，因此它会忽略该数字并继续处理下一个数字。由于奇数的模数不等于零，因此会执行循环的else部分并打印出来。

解决方案 18：

pass 用于避免 Python 中的缩进错误。

如果我们采用 C、C++ 和 Java 等语言，它们有如下括号：

 if(i==0)
 {}
 else
 {//some code}

但是在 Python 中我们使用缩进而不是括号，因此为了避免这样的错误我们使用pass。

记得在玩问答游戏的时候

if(dont_know_the_answer)
    pass

示例程序，

for letter in 'geeksforgeeks':
    pass
print 'Last letter: ', letter