จะใช้คำสั่ง pass ได้อย่างไร

ฉันอยู่ในกระบวนการของการเรียนรู้ Python และฉันได้มาถึงส่วนเกี่ยวกับpassคำสั่ง คำแนะนำที่ฉันใช้กำหนดเป็นNullคำสั่งที่ใช้โดยทั่วไปเป็นตัวยึดตำแหน่ง

ฉันยังไม่เข้าใจความหมายที่แท้จริง ใครสามารถแสดงสถานการณ์ที่เรียบง่าย / พื้นฐานที่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คำสั่งไม่ได้ทำอะไรเป็นพิเศษ แต่มันสามารถทำหน้าที่เป็นตัวยึดตำแหน่งที่แสดงที่นี่

งูใหญ่มีความต้องการสร้างประโยคที่บล็อกรหัส (หลังจากif, except, def, classฯลฯ ) ไม่สามารถเป็นที่ว่างเปล่า อย่างไรก็ตามบล็อกรหัสเปล่ามีประโยชน์ในหลากหลายบริบทที่แตกต่างกันเช่นในตัวอย่างด้านล่างซึ่งเป็นกรณีการใช้งานที่พบบ่อยที่สุดที่ฉันเคยเห็น

ดังนั้นถ้าอะไรที่ควรจะเกิดขึ้นในการป้องกันรหัสที่เป็นสิ่งจำเป็นสำหรับบล็อกดังกล่าวจะไม่ได้ผลิตpass IndentationErrorอีกทางเลือกหนึ่งข้อความใด ๆ (รวมถึงแค่คำที่จะประเมินเช่นEllipsisตัวอักษร...หรือสตริงส่วนใหญ่มักจะเป็น docstring) สามารถนำมาใช้ แต่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:นี้ถือว่าเป็นแนวปฏิบัติที่ดีกว่ามาก การวิเคราะห์อย่างรวดเร็วของโมดูลหลามทั้งหมดที่ฉันติดตั้งให้ฉันว่ามากกว่า 10% ของexcept ...: passงบทั้งหมดจับข้อยกเว้นทั้งหมดดังนั้นจึงยังคงเป็นรูปแบบที่พบบ่อยในการเขียนโปรแกรมหลาม

• การรับคลาสยกเว้นที่ไม่เพิ่มพฤติกรรมใหม่ (เช่นในscipy):

  class CompileError(Exception):
      pass

  ในทำนองเดียวกันคลาสที่ตั้งใจเป็นคลาสฐานนามธรรมมักจะมีวิธีการที่ชัดเจน__init__หรือวิธีอื่น ๆ ที่ subclasses ควรจะได้รับ (เช่น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

• ในคำจำกัดความของคลาสหรือฟังก์ชันมักจะมี docstring อยู่แล้วในฐานะคำสั่งบังคับที่จะดำเนินการเป็นสิ่งเดียวในบล็อก ในกรณีเช่นนี้บล็อกอาจมีส่วนpass เพิ่มเติมนอกเหนือจาก docstring เพื่อพูดว่า "นี่เป็นเจตนาที่จะไม่ทำอะไรเลย" ตัวอย่างเช่นในpebl:

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

• ในบางกรณีpassจะใช้เป็นตัวยึดจะพูดว่า“/ / บล็อกนี้ถ้าวิธีการเรียน / ... ยังไม่ได้รับการดำเนินการ แต่นี้จะเป็นสถานที่ที่จะทำมัน” แม้ว่าผมเองชอบEllipsisที่แท้จริง...เพื่อที่จะ แยกความแตกต่างระหว่างสิ่งนี้กับ "no-op" โดยเจตนาในตัวอย่างก่อนหน้านี้ ( โปรดสังเกตว่าตัวอักษรจุดไข่ปลาเป็นนิพจน์ที่ถูกต้องเฉพาะใน 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สิ่งนี้มีประโยชน์โดยเฉพาะอย่างยิ่งสำหรับสองกรณี: “ วิธีนามธรรมนี้ควรนำไปใช้โดยคลาสย่อยทุกคลาสไม่มีวิธีทั่วไปในการกำหนดในคลาสพื้นฐานนี้”หรือ“ ฟังก์ชันนี้ด้วย ชื่อนี้ยังไม่ได้นำมาใช้ในรีลีสนี้ แต่นี่คือลักษณะที่จะมีลักษณะของมัน” )

นอกจากการใช้เป็นตัวยึดสำหรับฟังก์ชันที่passยังไม่ได้ใช้งานแล้วจะมีประโยชน์ในการเติมคำสั่ง if-else ("Explicit is better than implicit")

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ในทุกกรณี

อีกกรณีหนึ่งคือฟังก์ชั่น boilerplate มักจะเห็นที่ด้านล่างของไฟล์:

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

จะเห็นได้ชัดว่าสร้าง ZeroDivisionError ถ้า b เป็นศูนย์ ในสถานการณ์เฉพาะนี้การปล่อยให้ c เป็นศูนย์เป็นพฤติกรรมที่ต้องการในกรณีที่ b เป็นศูนย์ดังนั้นฉันจึงใช้รหัสต่อไปนี้:

try:
    c = a / b
except ZeroDivisionError:
    pass

การใช้งานมาตรฐานที่น้อยกว่านั้นเป็นจุดที่สะดวกสำหรับวางจุดพักสำหรับดีบักเกอร์ของคุณ ตัวอย่างเช่นฉันต้องการรหัสเล็กน้อยที่จะเจาะเข้าไปในดีบักเกอร์ในการทำซ้ำคำสั่งที่ 20 ของ for ... in ดังนั้น:

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

ด้วยจุดพักเมื่อผ่าน

กรณีการใช้งานทั่วไปที่สามารถใช้ 'ตามที่เป็น' คือการแทนที่คลาสเพียงเพื่อสร้างประเภท (ซึ่งเป็นอย่างอื่นเช่นเดียวกับซูเปอร์คลาส) เช่น

class Error(Exception):
    pass

ดังนั้นคุณสามารถยกระดับและตรวจจับErrorข้อยกเว้น สิ่งที่สำคัญที่นี่คือประเภทของข้อยกเว้นมากกว่าเนื้อหา

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): # programmer wants to implement the body of the function later
       pass

passส่วนใหญ่จะใช้เมื่อโปรแกรมเมอร์ไม่ต้องการให้มีการนำไปใช้ในขณะนี้ แต่ยังต้องการสร้างคำสั่ง class / function / condition ที่แน่นอนซึ่งสามารถใช้ในภายหลังได้ เนื่องจาก Python interpreter ไม่อนุญาตให้ใช้คำสั่งคลาส / ฟังก์ชั่น / เงื่อนไข / ที่ว่างเปล่าหรือไม่มีการดำเนินการจึงทำให้เกิดข้อผิดพลาด:

IndentationError: คาดว่าบล็อกที่เยื้อง

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 "

ตอนนี้ฉันคิดว่ามันชัดเจนสำหรับคุณ

ฉันชอบที่จะใช้มันเมื่อขัดการทดสอบ ฉันมักจะรู้ว่าสิ่งที่ฉันต้องการที่จะทดสอบ แต่ไม่รู้ว่าจะทำอย่างไร ตัวอย่างการทดสอบดูเหมือนสิ่งที่แนะนำ sebastian_oe

class TestFunctions(unittest.TestCase):

   def test_some_feature(self):
      pass

   def test_some_other_feature(self):
      pass

คำสั่ง pass ไม่ได้ทำอะไรเลย สามารถใช้เมื่อต้องการคำสั่งทางไวยากรณ์ แต่โปรแกรมไม่ต้องการการดำเนินการ

สุจริตฉันคิดว่าเอกสาร Python อย่างเป็นทางการอธิบายได้ค่อนข้างดีและให้ตัวอย่าง:

ผ่านคำสั่งไม่ทำอะไรเลย สามารถใช้เมื่อต้องการคำสั่งทางไวยากรณ์ แต่โปรแกรมไม่ต้องดำเนินการใด ๆ ตัวอย่างเช่น:

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

สิ่งนี้มักใช้สำหรับการสร้างคลาสที่น้อยที่สุด:

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

สามารถใช้บัตรผ่านสถานที่อีกใบได้ในฐานะผู้แทนสถานที่สำหรับฟังก์ชั่นหรือร่างกายที่มีเงื่อนไขเมื่อคุณทำงานกับรหัสใหม่ช่วยให้คุณคิดในระดับนามธรรมมากขึ้น ผ่านจะถูกละเว้นเงียบ:

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

อย่างที่หนังสือบอกฉันเคยใช้มันเป็นตัวยึดตำแหน่งชั่วคราวเช่น

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

จากนั้นกรอกข้อมูลในภายหลังในกรณีที่ var == 2000

Pass หมายถึงการเพิกเฉย ... ง่ายๆเท่าที่จะเป็น ... ถ้าเงื่อนไขที่กำหนดเป็นจริงและข้อความสั่งถัดไปคือ pass มันจะไม่สนใจค่าหรือการวนซ้ำนั้นและดำเนินการในบรรทัดถัดไป ..... ตัวอย่าง

For i in range (1,100):
    If i%2==0:
                  Pass 
    Else:
                  Print(i)

ผลลัพธ์: พิมพ์เลขคี่ทั้งหมดตั้งแต่ 1-100

นี่เป็นเพราะโมดูลัสของเลขคู่เท่ากับศูนย์ดังนั้นมันจึงไม่สนใจจำนวนและดำเนินต่อไปยังหมายเลขถัดไปเนื่องจากตัวเลขคี่โมดูลัสไม่เท่ากับศูนย์ส่วนอื่นของลูปจะถูกดำเนินการและพิมพ์ออกมา

นี่คือตัวอย่างที่ฉันดึงข้อมูลเฉพาะจากรายการที่ฉันมีหลายประเภทข้อมูล (นั่นคือสิ่งที่ฉันเรียกมันใน R - ขอโทษถ้ามันเป็นระบบการตั้งชื่อผิด) และฉันต้องการที่จะดึงข้อมูลจำนวนเต็ม / ตัวเลขเท่านั้น .

ข้อมูลดูเหมือนว่า:

>>> a = ['1', 'env', '2', 'gag', '1.234', 'nef']
>>> data = []
>>> type(a)
<class 'list'>
>>> type(a[1])
<class 'str'>
>>> type(a[0])
<class 'str'>

ฉันต้องการลบตัวอักษรตามตัวอักษรทั้งหมดดังนั้นฉันจึงให้เครื่องทำมันโดยการย่อยข้อมูลและ "ส่งผ่าน" เหนือข้อมูลตัวอักษร:

a = ['1', 'env', '2', 'gag', '1.234', 'nef']
data = []
for i in range(0, len(a)):
    if a[i].isalpha():
        pass
    else:
        data.append(a[i])
print(data)
['1', '2', '1.234']

คำสั่ง pass ใน Python ถูกใช้เมื่อต้องการคำสั่งทาง syntactically แต่คุณไม่ต้องการให้คำสั่งหรือรหัสใด ๆ ในการดำเนินการ

ข้อความสั่ง 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 เพื่อไม่ให้รบกวนส่วนอื่น ๆ ของรหัส

pass ถูกใช้เพื่อหลีกเลี่ยงข้อผิดพลาดการเยื้องในไพ ธ อนถ้าเราใช้ภาษาเช่น c, c ++, java พวกมันจะมีเครื่องหมายวงเล็บเหมือนกัน

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

แต่ในไพ ธ อนนั้นใช้การเยื้องแทนการจัดฟันเพื่อหลีกเลี่ยงข้อผิดพลาดที่เราใช้ผ่าน จำได้ว่าคุณกำลังเล่นคำถามและ

 if(dont_know_the_answer)
      pass

โปรแกรมตัวอย่าง

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