如何使用pass语句

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

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


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

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

然后你会得到一个:

IndentationError: expected an indented block

总之，pass语句没有做任何特殊的事情，但它可以作为一个占位符，如这里所示。

正如书中所说，我只把它用作临时占位符，也就是说，

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

然后在后面填充var == 2000。

一个可以“按原样”使用的常见用例是重写一个类来创建一个类型(在其他方面与超类相同)，例如。

class Error(Exception):
pass

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

除了用作未实现函数的占位符外，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在两个特别提到的情况中被设置，但在__abc2情况中没有。如果不使用pass，未来的程序员可能会将flag = True移到条件之外——从而在所有情况下设置flag。

另一种情况是经常出现在文件底部的样板函数:

if __name__ == "__main__":
pass

在某些文件中，最好将其与pass一起留在那里，以便稍后更容易地编辑，并明确表示当文件单独运行时不期望发生任何事情。

最后，正如在其他回答中提到的，当异常被捕获时，什么都不做是很有用的:

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

最好和最准确的理解pass的方式是显式地告诉解释器什么都不做。以同样的方式输入以下代码:

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

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

def bar():
pass

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

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

例如，在我最近编写的一段代码中，有必要对两个变量进行除法，并且除数可能为零。

c = a / b

显然，如果b为零，将产生一个ZeroDivisionError。在这种特殊情况下，在b为零的情况下，让c为零是理想的行为，所以我使用了以下代码:

try:
c = a / b
except ZeroDivisionError:
pass

另一种不太标准的用法是为调试器放置断点。例如，我想要一段代码在For语句的第20次迭代时进入调试器。在声明。所以:

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

在传递时使用断点。

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被用作占位符，表示“This method/class/if-block/…”虽然我个人更喜欢Ellipsis文字...，以便严格区分这和前面例子中故意的“no-op”。(注意，省略符号只在python3中是有效的表达式)

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

   def update_agent(agent):
  ...
  

  其他人可能有

   def update_agent(agent):
  pass
  

  之前

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

  作为一个提醒，在稍后填写update_agent函数，但已经运行一些测试，看看其余的代码是否如预期的那样运行。(这种情况下的第三个选项是raise NotImplementedError。这在两种情况下特别有用:“这个抽象方法应该由每个子类实现，在这个基类中没有通用的方法来定义它”或这个函数，这个名字，还没有在这个版本中实现，但它的签名将是这样的)

pass语句什么也不做。当语法上需要语句，但程序不需要操作时，可以使用它。

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可以在这种情况下使用。

在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语句，这样它就不会干扰代码的其他部分。

你可以说通过意味着一个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之后需要一个缩进的块。下面是通过关键字的作用。

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 "

现在我想你们都清楚了。

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

通过语句什么都不做。当语法上需要语句，但程序不需要操作时，可以使用它。例如:

< p > <代码>祝辞祝辞祝辞而真正的: …通过#繁忙等待键盘中断(Ctrl+C) 代码…< / > < / p >

这通常用于创建最小类:

< p > <代码>祝辞祝辞祝辞类MyEmptyClass: …通过 代码…< / > < / p >

通过的另一个用途是在编写新代码时作为函数或条件体的占位符，使您可以在更抽象的级别上进行思考。通过被默默地忽略:

< p > <代码>祝辞祝辞祝辞def initlog (* args): …记住要实现这个! 代码…< / > < / p >

Pass指忽略…就是这么简单。如果给定条件为真，下一个语句为通过，则忽略该值或迭代并继续下一行。

例子:

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

输出:输出1-100之间的所有奇数

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

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

如果我们以C、c++和Java等语言为例，它们有这样的大括号:

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

但在Python中，我们使用缩进而不是大括号，因此为了避免此类错误，我们使用通过。

记得你在做测验的时候

if(dont_know_the_answer)
pass

示例程序,

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

如果你想导入一个模块，如果它存在，并且忽略导入它，如果该模块不存在，你可以使用下面的代码:

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

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

除了“main”;使用“I don't want anything to go here，”;这是我刚刚找到的一个，假设gen是Iterator:

i = 0
obj = None


for i, obj in enumerate(gen):
pass

这将在一次传递中获得gen的最后一个对象yielded和gen的长度。(有点类似于while循环，在C中以分号结束，仔细想想。)

通过通常是有用的,当你写代码来设计该类型的游戏什么的,现在你继续代码,你会意识到,有一些功能你不想前进,想把它原封不动和进一步的代码,然后重新审视函数之后,但是当你这样做,编译器将明显抛出一个错误说它不是公认的和其他各种各样的东西! !在这种情况下，你使用通过，这样编译器就会忽略这个函数，并继续执行代码!!

例如:

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

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

谢谢!

首先，如果你想写一个block，像这样:

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

pass可以是一个占位符。

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。