Python：自动初始化实例变量？ [英] Python: Automatically initialize instance variables?

问题描述

我有一个类似这样的python类：

 类进程：
 def __init __ ，PPID，cmd，FDs，reachable，user）：
  

后跟：

  self.PID = PID 
 self.PPID = PPID 
 self.cmd = cmd 
 ... 
  

有没有办法自动初始化这些实例变量，如C ++的初始化列表？

编辑：扩展解决方案以符合默认参数

这是完整的解决方案：

  from functools import wraps 
 import inspect 
 
 
 def initializer（func）：

自动分配参数
 
> ;> class process：
 ... @initializer 
 ... def __init __（self，cmd，reachable = False，user ='root'）：
 ... pass 
>>>> p = process（'halt'，True）
>>> p.cmd，p.reachable，p.user 
 'root'）

 names，varargs，keywords，defaults = inspect.getargspec（func）
 
 @wraps（func）
 def wrapper ，* args，** kargs）：
 for name，arg in list（zip（names [1：]，args））+ list（kargs.items（））：
 setattr ，arg）
 
名称，默认为zip（反向（名称），反向（默认））：
如果没有hasattr（self，name）：
 setattr name，default）
 
 func（self，* args，** kargs）
 
返回wrapper 
  

---

编辑：Adam要求我扩展解决方案以支持关键字参数

  from functools import wraps 
 import inspect 
 
 def initializer（fun）：
 names，varargs，keywords ，defaults = inspect.getargspec（fun）
 @wraps（fun）
 def wrapper（self，* args，** kargs）：
为name， ]，args）+ kargs.items（）：
 setattr（self，name，arg）
 fun（self，* args，** kargs）
 return wrapper 
  
 
 
 
 
 
 
您可以使用装饰器：
  from functools import wraps 
 import inspect 
 
 def initializer（fun）：
 names，varargs，keywords，defaults = inspect.getargspec（fun）
 @wraps（fun）
 def wrapper（self，* args）：
 name，arg in zip（names [1：]，args）：
 setattr（self，name，arg）
 fun（self，* args）
返回包装器
 
类进程：
 @initializer 
 def __init__ （self，PID，PPID，cmd，FDs，可达，用户）：
 pass 
  
输出：
 >>> c = process（1，2，3，4，5，6）
>>>> c.PID 
 1 
>>>> dir（c）
 ['FDs'，'PID'，'PPID'，'__doc__'，'__init__'，'__module__'，'cmd'，'reachable'，'user'
  
 
I have a python class that looks like this:
class Process:
    def __init__(self, PID, PPID, cmd, FDs, reachable, user):
followed by:
        self.PID=PID
        self.PPID=PPID
        self.cmd=cmd
        ...
Is there any way to autoinitialize these instance variables, like C++'s initialization list? It would spare lots of redundant code.
解决方案
Edit: extended the solution to honor default arguments also


Here is the complete solution:
from functools import wraps
import inspect


def initializer(func):
    """
    Automatically assigns the parameters.

    >>> class process:
    ...     @initializer
    ...     def __init__(self, cmd, reachable=False, user='root'):
    ...         pass
    >>> p = process('halt', True)
    >>> p.cmd, p.reachable, p.user
    ('halt', True, 'root')
    """
    names, varargs, keywords, defaults = inspect.getargspec(func)

    @wraps(func)
    def wrapper(self, *args, **kargs):
        for name, arg in list(zip(names[1:], args)) + list(kargs.items()):
            setattr(self, name, arg)

        for name, default in zip(reversed(names), reversed(defaults)):
            if not hasattr(self, name):
                setattr(self, name, default)

        func(self, *args, **kargs)

    return wrapper




Edit: Adam asked me to extend the solution to support keyword arguments
from functools import wraps
import inspect

def initializer(fun):
   names, varargs, keywords, defaults = inspect.getargspec(fun)
   @wraps(fun)
   def wrapper(self, *args, **kargs):
       for name, arg in zip(names[1:], args) + kargs.items():
           setattr(self, name, arg)
       fun(self, *args, **kargs)
   return wrapper




You can use a decorator:
from functools import wraps
import inspect

def initializer(fun):
    names, varargs, keywords, defaults = inspect.getargspec(fun)
    @wraps(fun)
    def wrapper(self, *args):
        for name, arg in zip(names[1:], args):
            setattr(self, name, arg)
        fun(self, *args)
    return wrapper

class process:
    @initializer
    def __init__(self, PID, PPID, cmd, FDs, reachable, user):
        pass
Output:
>>> c = process(1, 2, 3, 4, 5, 6)
>>> c.PID
1
>>> dir(c)
['FDs', 'PID', 'PPID', '__doc__', '__init__', '__module__', 'cmd', 'reachable', 'user'


                        
这篇关于Python：自动初始化实例变量？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！