เป็นการดีที่จะประกาศตัวแปรอินสแตนซ์ว่าไม่มีในคลาสใน Python หรือไม่?

พิจารณาคลาสต่อไปนี้:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

เพื่อนร่วมงานของฉันมักจะนิยามเช่นนี้:

class Person:
    name = None
    age = None

    def __init__(self, name, age):
        self.name = name
        self.age = age

เหตุผลหลักสำหรับสิ่งนี้คือตัวเลือกที่แก้ไขจะแสดงคุณสมบัติของการเติมข้อความอัตโนมัติ

Noneส่วนตัวผมไม่ชอบหลังหนึ่งเพราะมันทำให้รู้สึกว่าชั้นมีคุณสมบัติเหล่านั้นตั้งค่าให้ไม่มี

อันไหนจะเป็นการฝึกฝนที่ดีกว่าและด้วยเหตุผลอะไร

ฉันเรียกการปฏิบัติที่ไม่ดีหลังภายใต้กฎ "สิ่งนี้ไม่ได้ทำในสิ่งที่คุณคิดว่าเป็น"

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

1. ทำให้รหัสของคุณง่ายต่อการเข้าใจ

รหัสอ่านบ่อยกว่าที่เขียน ทำให้งานของผู้ดูแลโค้ดของคุณง่ายขึ้น (และอาจเป็นตัวคุณเองในปีหน้า)

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

ดังนั้นฉันมักจะไม่เพียง แต่กำหนดทุกอย่างในตัวสร้าง แต่ยังพยายามรักษาจำนวนของคุณลักษณะที่ไม่แน่นอนให้น้อยที่สุด

2. อย่าผสมสมาชิกระดับชั้นเรียนและระดับอินสแตนซ์

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

สมาชิกข้อมูลระดับชั้นมีประโยชน์มากที่สุดในฐานะค่าคงที่:

class Missile(object):
  MAX_SPEED = 100  # all missiles accelerate up to this speed
  ACCELERATION = 5  # rate of acceleration per game frame

  def move(self):
    self.speed += self.ACCELERATION
    if self.speed > self.MAX_SPEED:
      self.speed = self.MAX_SPEED
    # ...

ส่วนตัวฉันกำหนดสมาชิกในเมธอด __ init __ () ฉันไม่เคยคิดถึงการกำหนดไว้ในส่วนของชั้นเรียน แต่สิ่งที่ฉันทำอยู่เสมอ: ฉันเริ่มสมาชิกทั้งหมดในเมธอด __ init__ แม้จะไม่จำเป็นในเมธอด __ init__ ก็ตาม

ตัวอย่าง:

class Person:
    def __init__(self, name, age):
        self._name = name
        self._age = age
        self._selected = None

   def setSelected(self, value):
        self._selected = value

ฉันคิดว่ามันเป็นสิ่งสำคัญที่จะกำหนดสมาชิกทั้งหมดในที่เดียว ทำให้โค้ดอ่านง่ายขึ้น ไม่ว่าจะอยู่ใน __ init __ () หรือภายนอกก็ไม่สำคัญ แต่มันเป็นสิ่งสำคัญสำหรับทีมที่จะมอบสไตล์การเข้ารหัสที่เหมือนกันหรือมากกว่านั้น

โอ้และคุณอาจสังเกตเห็นว่าฉันเคยเพิ่มคำนำหน้า "_" ลงในตัวแปรสมาชิก

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

พิจารณา:

>>> class WithNone:
...   x = None
...   y = None
...   def __init__(self, x, y):
...     self.x = x
...     self.y = y
... 
>>> class InitOnly:
...   def __init__(self, x, y):
...     self.x = x
...     self.y = y
... 
>>> wn = WithNone(1,2)
>>> wn.x
1
>>> WithNone.x #Note that it returns none, no error
>>> io = InitOnly(1,2)
>>> InitOnly.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: class InitOnly has no attribute 'x'

ฉันจะไปกับ "นิดหน่อยเหมือน docstrings แล้ว" และประกาศสิ่งนี้ไม่เป็นอันตรายตราบใดที่มันยังอยู่เสมอNoneหรือในช่วงแคบ ๆ ของค่าอื่น ๆ ทั้งหมดไม่เปลี่ยนรูป

มัน reeks ของ atavism และสิ่งที่แนบมามากเกินไปกับภาษาที่พิมพ์แบบคงที่ และมันก็ไม่ได้ดีเท่าโค้ด แต่มันมีจุดประสงค์เล็ก ๆ น้อย ๆ ที่ยังคงอยู่ในเอกสาร

มันบันทึกชื่อที่คาดหวังไว้ดังนั้นถ้าฉันรวมรหัสกับใครบางคนและหนึ่งในนั้นมี 'ชื่อผู้ใช้' และชื่อผู้ใช้คนอื่น ๆ ก็มีร่องรอยของมนุษย์ที่เราแยกทางและไม่ได้ใช้ตัวแปรเดียวกัน

การบังคับใช้การเริ่มต้นเต็มรูปแบบเป็นนโยบายที่ประสบความสำเร็จในแบบ Pythonic แต่ถ้ามีรหัสจริงใน__init__นี้จะให้ที่ที่ชัดเจนในการจัดทำเอกสารตัวแปรที่ใช้

เห็นได้ชัดว่าปัญหาใหญ่ที่นี่คือมันล่อลวงคนที่จะเริ่มต้นด้วยค่าอื่น ๆNoneซึ่งอาจไม่ดี:

class X:
    v = {}
x = X()
x.v[1] = 2

ออกจากการติดตามทั่วโลกและไม่สร้างอินสแตนซ์สำหรับ x

แต่นั่นเป็นสิ่งที่แปลกประหลาดใน Python โดยรวมมากกว่าในการฝึกฝนนี้และเราควรหวาดระแวงเกี่ยวกับเรื่องนี้