什麼是創建類屬性的'Python'方法

Question

我是Python的初學者。我想知道這是創建屬性更好的辦法...

在第一種方法，我明確地定義屬性，然後有一個方法返回一個值給它：

class A: 
    def __init__(self, number): 
     self.a = self._meth(number) 

    def _meth(self, num): 
     #some executable code here 

     return 8 ** num 

在第二種方法是自己調用該方法，並通過它自己創建屬性。

class A: 
    def __init__(self, number): 
     self._meth(num) 

    def _meth(self, num) 
     #some executable code here 
     self.a = 8 ** num 

所以我的問題是哪一個是要對這個比較認可的方法是什麼？

這是我想用這個...

class Initializer(): 
    def __init__(self): 
     self.ParseArguments() 
     self.InitializeLogger() 

    # Parse command line arguments and display help text  
    def ParseArguments(self): 
     help = textwrap.dedent('''\ Help text here''') 
     Arguments = argparse.ArgumentParser('This Script Pulls NAV data from the ' 
          'AMFI website', 
          formatter_class=argparse.RawDescriptionHelpFormatter, 
          description=help) 
     Arguments.add_argument('-f', '--file', 
           help= 'location of the config') 
     self.ArgumentDict = vars(Arguments.parse_args()) 
     self.ArgumentParser = Arguments 




    def CreateLogFile(self, level, name,): 
     path = self.ArgumentDict['loc'] 
     if path == None: 
      if platform.system() == 'Windows': 
       location = os.environ.get("TEMP") + '\\' + name 
      elif platform.system == 'Linux': 
       location = os.getenv("HOME") + '/' + name 
      else: 
       print "Unsupported OS" 
       raise ValueError 
     else: 
      location = path 
     formatter = logging.Formatter("%(asctime)s - %(name)s - " 
             "%(levelname)s - %(message)s") 
     logfile = logging.FileHandler(location) 
     logfile.setLevel(logging.DEBUG) 
     logfile.setFormatter(formatter) 
     self.logger.addHandler(logfile) 


    def InitializeLogger(self): 
     self.logger = logging.getLogger('main') 
     if self.ArgumentDict['debug'] == True: 
      self.logger.setLevel(logging.DEBUG) 
     else: 
      self.logger.setLevel(logging.INFO) 
     self.CreateLogFile(logging.INFO, 'NavUpdaterLog.log')) 

Answer 1

注意，我們在創建對象屬性的代碼，而不是類屬性（那些直接在類體內）。如果meth只呼籲初始化，我寧願：

class A(object): 
    def __init__(): 
     # Some executable code here 
     self.a = 8 

否則，如果你的類不能處理meth被稱爲飄飛，你應該用_或前綴使其成爲一個私有方法__。

順便說return None（用大寫Ñ一個）在方法結束時是不必要的，這是默認的最終指令反正。

看着更新後的代碼，我找不到任何需要首先使用類的地方。你可能想要一個幫手方法initLogger，但就是這樣。嘗試：內置式功能，而不是自己重新實現它

• 使用，例如tempfile
• 大致遵循PEP8在你的風格（即不利用方法和變量名）

Answer 2

在你的第二個定義，你只能使用該方法來設置實例變量a。在你的第一個，你可以再次使用該方法，如果你需要它。另外，我不喜歡在實例變量的所有位置查找，所以我會選擇第一位。

Answer 3

我認爲正確的python方式將是最簡單的方法，刪除所有不必要的代碼。

class A(): 
    def __init__(self): 
     self.a = 8 

如果您需要定義自定義getter和setter方法，你可以使用python properties。這在從python文檔提取：

class C(object): 
    def __init__(self): 
     self._x = None 

    @property 
    def x(self): 
     """I'm the 'x' property.""" 
     return self._x 

    @x.setter 
    def x(self, value): 
     self._x = value 

    @x.deleter 
    def x(self): 
     del self._x 

Answer 4

我認爲答案是，它取決於。如果只有一個屬性，就像在你的例子中那樣，那麼整個meth可以進入__init__方法。如果你有5-10個屬性來初始化，__init__會變長，我肯定會嘗試將初始化代碼重構爲函數。如果每個屬性的初始化獨立於另一個，我會首先嚐試使用函數。

def get_attr_a(): 
    # some code 
    return a 
def get_attr_b(): 
    ... 
    return b 
... 
class A: 
    def __init__(): 
     self.a = get_attr_a() 
     self.b = get_attr_b() 
     ... 

如果屬性的初始化取決於對方，所以前一個完成是b不能被初始化，則它是一個棘手的情況。這可能保證某種工廠模式，其中對象的初始化從類分離：創建屬性

class A: 
    def__init__(self, a, b, c): 
     self.a, self.b, self.c = a, b, c 

def get_attr_a(): 
    return a 
def get_attr_b(a): 
    return b 
def create_an_a_class(): 
    a = get_attr_a() 
    b = get_attr_b(a) 
    c = get_attr_c(a, b) 
    .... 
    return A(a, b, c) 

Answer 5

在使用init是一種可以理解的方式（其他程序員）。

通常__ init __是你的方式我開始閱讀python類並掃描方法。