ตัวแปรอินสแตนซ์เทียบกับตัวแปรคลาสใน Python

ฉันมีคลาส Python ซึ่งฉันต้องการเพียงอินสแตนซ์เดียวที่รันไทม์ดังนั้นจึงเพียงพอที่จะมีแอตทริบิวต์เพียงครั้งเดียวต่อคลาสและไม่ใช่ต่ออินสแตนซ์ หากมีมากกว่าหนึ่งอินสแตนซ์ (ซึ่งจะไม่เกิดขึ้น) อินสแตนซ์ทั้งหมดควรมีการกำหนดค่าเหมือนกัน ฉันสงสัยว่าตัวเลือกใดต่อไปนี้จะดีกว่าหรือมากกว่า Python "สำนวน"

ตัวแปรคลาส:

class MyController(Controller):

  path = "something/"
  children = [AController, BController]

  def action(self, request):
    pass

ตัวแปรอินสแตนซ์:

class MyController(Controller):

  def __init__(self):
    self.path = "something/"
    self.children = [AController, BController]

  def action(self, request):
    pass

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

สะท้อนคำแนะนำของ MikeและAlex เพิ่มเติมและเพิ่มสีของตัวเอง ...

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

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

1. ชาวบ้าน
2. nonlocals
3. Globals
4. สร้างอิน

สำหรับการเข้าถึงแอตทริบิวต์ลำดับคือ:

1. ตัวอย่าง
2. ชั้น
3. คลาสพื้นฐานตามที่กำหนดโดยMRO (ลำดับวิธีการแก้ปัญหา)

เทคนิคทั้งสองทำงานในลักษณะ "ภายใน - ภายนอก" ซึ่งหมายความว่าจะมีการตรวจสอบวัตถุในพื้นที่มากที่สุดก่อนจากนั้นจึงตรวจสอบชั้นนอกตามลำดับ

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

อย่างไรก็ตามหากคุณยืนยันในแอตทริบิวต์คลาสคุณต้องมีการค้นหาเพิ่มเติม หรือทางเลือกอื่น ๆ ของคุณคือการอ้างถึงวัตถุที่ผ่านการเรียนแทนตัวอย่างเช่นแทนMyController.path self.pathนั่นคือการค้นหาโดยตรงซึ่งจะได้รับการค้นหาที่รอการตัดบัญชี แต่ตามที่ alex กล่าวถึงด้านล่างนี้เป็นตัวแปรส่วนกลางดังนั้นคุณจึงสูญเสียบิตที่คุณคิดว่าจะบันทึก (เว้นแต่คุณจะสร้างการอ้างอิงในท้องถิ่นไปยังชื่อคลาส [global] )

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

หากมีข้อสงสัยคุณอาจต้องการแอตทริบิวต์อินสแตนซ์

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

คำถามเดียวกันกับประสิทธิภาพการเข้าถึงตัวแปรคลาสใน Python - โค้ดที่นี่ดัดแปลงมาจาก @Edward Loper

ตัวแปรในเครื่องเป็นตัวแปรที่เข้าถึงได้เร็วที่สุดโดยเชื่อมโยงกับตัวแปรโมดูลตามด้วยตัวแปรคลาสตามด้วยตัวแปรอินสแตนซ์

มี 4 ขอบเขตที่คุณสามารถเข้าถึงตัวแปรจาก:

1. ตัวแปรอินสแตนซ์ (self.varname)
2. ตัวแปรคลาส (Classname.varname)
3. ตัวแปรโมดูล (VARNAME)
4. ตัวแปรท้องถิ่น (varname)

การทดสอบ:

import timeit

setup='''
XGLOBAL= 5
class A:
    xclass = 5
    def __init__(self):
        self.xinstance = 5
    def f1(self):
        xlocal = 5
        x = self.xinstance
    def f2(self):
        xlocal = 5
        x = A.xclass
    def f3(self):
        xlocal = 5
        x = XGLOBAL
    def f4(self):
        xlocal = 5
        x = xlocal
a = A()
'''
print('access via instance variable: %.3f' % timeit.timeit('a.f1()', setup=setup, number=300000000) )
print('access via class variable: %.3f' % timeit.timeit('a.f2()', setup=setup, number=300000000) )
print('access via module variable: %.3f' % timeit.timeit('a.f3()', setup=setup, number=300000000) )
print('access via local variable: %.3f' % timeit.timeit('a.f4()', setup=setup, number=300000000) )

ผลลัพธ์:

access via instance variable: 93.456
access via class variable: 82.169
access via module variable: 72.634
access via local variable: 72.199