if hasattr(obj, 'attribute'):
    # do somthing

เทียบกับ

try:
    # access obj.attribute
except AttributeError, e:
    # deal with AttributeError

ควรเลือกแบบไหนและเพราะเหตุใด

hasattrภายในและรวดเร็วทำงานเช่นเดียวกับtry/exceptบล็อก: เป็นเครื่องมือที่เฉพาะเจาะจงมากที่สุดได้รับการปรับให้เหมาะสมและเป็นงานเดียวดังนั้นจึงควรเป็นที่ต้องการสำหรับทางเลือกที่ใช้งานทั่วไป

ม้านั่งใดที่แสดงให้เห็นถึงความแตกต่างในประสิทธิภาพ?

ถึงเวลาก็คือเพื่อนของคุณ

$ python -mtimeit -s 'class C(object): a = 4
c = C()' 'hasattr(c, "nonexistent")'
1000000 loops, best of 3: 1.87 usec per loop
$ python -mtimeit -s 'class C(object): a = 4
c = C()' 'hasattr(c, "a")'
1000000 loops, best of 3: 0.446 usec per loop
$ python -mtimeit -s 'class C(object): a = 4
c = C()' 'try:
 c.a
except:
 pass'
1000000 loops, best of 3: 0.247 usec per loop
$ python -mtimeit -s 'class C(object): a = 4
c = C()' 'try:
 c.nonexistent
except:
 pass'
100000 loops, best of 3: 3.13 usec per loop
$

       |positive|negative
hasattr|  0.446 |  1.87 
try    |  0.247 |  3.13

มีทางเลือกที่สามและมักจะดีกว่า:

attr = getattr(obj, 'attribute', None)
if attr is not None:
     print attr

ข้อดี:

1. getattrไม่มีพฤติกรรมการกลืนข้อยกเว้นที่ไม่ดีที่Martin Geiser ชี้ให้เห็น - ใน Pythons เก่า ๆhasattrจะกลืนกKeyboardInterrupt.

2. เหตุผลปกติที่คุณกำลังตรวจสอบว่าวัตถุนั้นมีแอตทริบิวต์หรือไม่ก็เพื่อที่คุณจะสามารถใช้แอตทริบิวต์ได้และสิ่งนี้จะนำไปสู่มันโดยธรรมชาติ

3. แอตทริบิวต์ถูกอ่านออกโดยอะตอมและปลอดภัยจากเธรดอื่นที่เปลี่ยนวัตถุ (แม้ว่านี่จะเป็นข้อกังวลหลักคุณอาจต้องพิจารณาล็อกวัตถุก่อนเข้าถึง)

4. มันสั้นกว่าและมักจะสั้นกว่าtry/finallyhasattr

5. except AttributeErrorบล็อกกว้าง ๆสามารถจับสิ่งอื่นAttributeErrorsนอกเหนือจากที่คุณคาดหวังซึ่งอาจนำไปสู่พฤติกรรมที่สับสน

6. การเข้าถึงแอตทริบิวต์ช้ากว่าการเข้าถึงตัวแปรภายใน (โดยเฉพาะอย่างยิ่งถ้าไม่ใช่แอตทริบิวต์อินสแตนซ์ธรรมดา) (พูดตามตรงการเพิ่มประสิทธิภาพไมโครใน Python มักเป็นธุระของคนโง่)

สิ่งหนึ่งที่ต้องระวังคือหากคุณสนใจเกี่ยวกับกรณีที่obj.attributeตั้งค่าเป็นไม่มีคุณจะต้องใช้ค่ายามอื่น

ฉันมักจะใช้ hasattrมันเป็นตัวเลือกที่ถูกต้องสำหรับกรณีส่วนใหญ่

กรณีที่เป็นปัญหาคือเมื่อคลาสแทนที่__getattr__: hasattrจะจับข้อยกเว้นทั้งหมดแทนที่จะจับAttributeErrorเหมือนที่คุณคาดไว้ กล่าวอีกนัยหนึ่งโค้ดด้านล่างจะพิมพ์b: Falseแม้ว่าจะเหมาะสมกว่าหากเห็นValueErrorข้อยกเว้น:

class X(object):
    def __getattr__(self, attr):
        if attr == 'a':
            return 123
        if attr == 'b':
            raise ValueError('important error from your database')
        raise AttributeError

x = X()
print 'a:', hasattr(x, 'a')
print 'b:', hasattr(x, 'b')
print 'c:', hasattr(x, 'c')

ข้อผิดพลาดที่สำคัญจึงหายไป สิ่งนี้ได้รับการแก้ไขแล้วใน Python 3.2 ( issue9666 ) ซึ่งhasattrตอนนี้จับได้เท่านั้นAttributeErrorตอนนี้จับเท่านั้น

วิธีแก้ปัญหาง่ายๆคือการเขียนฟังก์ชันยูทิลิตี้ดังนี้:

_notset = object()

def safehasattr(thing, attr):
    return getattr(thing, attr, _notset) is not _notset

เรามาgetattrจัดการกับสถานการณ์และจะสามารถเพิ่มข้อยกเว้นที่เหมาะสมได้

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

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

บรรทัดล่าง: ฉันคิดว่ามันเป็นปัญหาการออกแบบและความสามารถในการอ่านมากกว่าปัญหาด้านประสิทธิภาพ

หากไม่มีแอตทริบิวต์ไม่ใช่เงื่อนไขข้อผิดพลาดตัวแปรการจัดการข้อยกเว้นจะมีปัญหา: มันจะจับ AttributeErrors ที่อาจเกิดขึ้นภายในเมื่อเข้าถึง obj.attribute (เช่นเนื่องจากแอตทริบิวต์เป็นคุณสมบัติเพื่อให้การเข้าถึงเรียกใช้รหัส)

หัวข้อนี้ครอบคลุมในการพูดคุย EuroPython 2016 การเขียน Python ที่เร็วขึ้นโดย Sebastian Witowski นี่คือการจำลองสไลด์ของเขาพร้อมสรุปประสิทธิภาพ นอกจากนี้เขายังใช้คำศัพท์ก่อนที่คุณจะก้าวกระโดดในการสนทนานี้ซึ่งควรค่าแก่การกล่าวถึงที่นี่เพื่อแท็กคำหลักนั้น

หากแอตทริบิวต์หายไปจริงการขอการให้อภัยจะช้ากว่าการขอสิทธิ์ ตามหลักทั่วไปคุณสามารถใช้วิธีขออนุญาตได้หากทราบว่ามีโอกาสมากที่แอตทริบิวต์จะหายไปหรือมีปัญหาอื่น ๆ ที่คุณสามารถคาดเดาได้ มิฉะนั้นหากคุณคาดหวังว่าโค้ดจะส่งผลให้โค้ดส่วนใหญ่สามารถอ่านได้

3 สิทธิ์หรือการให้อภัย?

# CASE 1 -- Attribute Exists
class Foo(object):
    hello = 'world'
foo = Foo()

if hasatter(foo, 'hello'):
    foo.hello
## 149ns ##

try:
    foo.hello
except AttributeError:
    pass
## 43.1 ns ##
## 3.5 times faster


# CASE 2 -- Attribute Absent
class Bar(object):
    pass
bar = Bar()

if hasattr(bar, 'hello'):
    bar.hello
## 428 ns ##

try:
    bar.hello
except AttributeError :
    pass
## 536 ns ##
## 25% slower

hasattrถ้ามันเป็นเพียงหนึ่งในคุณลักษณะที่คุณกำลังทดสอบผมว่าการใช้งาน อย่างไรก็ตามหากคุณกำลังเข้าถึงแอตทริบิวต์หลายรายการซึ่งอาจมีหรือไม่มีอยู่การใช้tryบล็อกอาจช่วยให้คุณประหยัดเวลาในการพิมพ์

ฉันขอแนะนำตัวเลือก 2 ตัวเลือกที่ 1 มีเงื่อนไขการแย่งชิงหากเธรดอื่นกำลังเพิ่มหรือลบแอตทริบิวต์

นอกจากนี้ python ยังมีสำนวน EAFP ('ง่ายกว่าที่จะขอการให้อภัยมากกว่าการอนุญาต') ดีกว่า LBYL ('ดูก่อนกระโดด')

จากมุมมองในทางปฏิบัติในภาษาส่วนใหญ่ที่ใช้เงื่อนไขจะเร็วกว่าการจัดการข้อยกเว้น

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

ดังที่ Rax Olgud ชี้ให้เห็นว่าการสื่อสารกับผู้อื่นเป็นคุณลักษณะที่สำคัญอย่างหนึ่งของรหัสและสิ่งที่คุณต้องการจะพูดโดยพูดว่า "นี่เป็นสถานการณ์พิเศษ" แทนที่จะเป็น "นี่คือสิ่งที่ฉันคาดว่าจะเกิดขึ้น" อาจสำคัญกว่า .

ครั้งแรก.

สั้นจะดีกว่า ข้อยกเว้นควรมีความพิเศษ

อย่างน้อยเมื่อมันขึ้นอยู่กับสิ่งที่เกิดขึ้นในโปรแกรมการละเว้นส่วนที่เป็นมนุษย์ของความสามารถในการอ่าน ฯลฯ (ซึ่งจริงๆแล้วเวลาส่วนใหญ่ไม่สำคัญมากกว่าประสิทธิภาพ (อย่างน้อยก็ในกรณีนี้ - ด้วยช่วงประสิทธิภาพนั้น) ตามที่ Roee Adler และคนอื่น ๆ ชี้ให้เห็น)

อย่างไรก็ตามเมื่อมองจากมุมมองนั้นมันก็กลายเป็นเรื่องของการเลือกระหว่าง

try: getattr(obj, attr)
except: ...

และ

try: obj.attr
except: ...

เนื่องจากhasattrใช้เพียงกรณีแรกในการพิจารณาผลลัพธ์ อาหารสมอง ;-)