Fieldobjects

Fieldobjects describe each defined field. These objects are created internally, and are returned by thefields()module-level method (see below). Users should never instantiate aField object directly. Its documented attributes are:

• name:The name of the field.
• type:The type of the field.
• default,default_factory,init,repr,hash, compare,andmetadatahave the identical meaning and values as they do in thefield()declaration.

Other attributes may exist, but they are private and must not be inspected or relied on.

post-init processing

The generated__init__code will call a method named __post_init__,if it is defined on the class. It will be called asself.__post_init__().If no__init__method is generated, then__post_init__will not automatically be called.

Among other uses, this allows for initializing field values that depend on one or more other fields. For example:

@dataclass
classC:
a:float
b:float
c:float=field(init=False)

def__post_init__(self):
self.c=self.a+self.b

See the section below on init-only variables for ways to pass parameters to__post_init__().Also see the warning about how replace()handlesinit=Falsefields.

Class variables

One place wheredataclassactually inspects the type of a field is to determine if a field is a class variable as defined inPEP 526.It does this by checking if the type of the field istyping.ClassVar. If a field is aClassVar,it is excluded from consideration as a field and is ignored by the Data Class mechanisms. For more discussion, see[8].SuchClassVarpseudo-fields are not returned by the module-levelfields()function.

Init-only variables

The other place wheredataclassinspects a type annotation is to determine if a field is an init-only variable. It does this by seeing if the type of a field is of typedataclasses.InitVar.If a field is anInitVar,it is considered a pseudo-field called an init-only field. As it is not a true field, it is not returned by the module-levelfields()function. Init-only fields are added as parameters to the generated__init__method, and are passed to the optional__post_init__method. They are not otherwise used by Data Classes.

For example, suppose a field will be initialized from a database, if a value is not provided when creating the class:

@dataclass
classC:
i:int
j:int=None
database:InitVar[DatabaseType]=None

def__post_init__(self,database):
ifself.jisNoneanddatabaseisnotNone:
self.j=database.lookup('j')

c=C(10,database=my_database)

In this case,fields()will returnFieldobjects foriand j,but not fordatabase.

Frozen instances

It is not possible to create truly immutable Python objects. However, by passingfrozen=Trueto the@dataclassdecorator you can emulate immutability. In that case, Data Classes will add __setattr__and__delattr__methods to the class. These methods will raise aFrozenInstanceErrorwhen invoked.

There is a tiny performance penalty when usingfrozen=True: __init__cannot use simple assignment to initialize fields, and must useobject.__setattr__.

Inheritance

When the Data Class is being created by the@dataclassdecorator, it looks through all of the class’s base classes in reverse MRO (that is, starting atobject) and, for each Data Class that it finds, adds the fields from that base class to an ordered mapping of fields. After all of the base class fields are added, it adds its own fields to the ordered mapping. All of the generated methods will use this combined, calculated ordered mapping of fields. Because the fields are in insertion order, derived classes override base classes. An example:

@dataclass
classBase:
x:Any=15.0
y:int=0

@dataclass
classC(Base):
z:int=10
x:int=15

The final list of fields is, in order,x,y,z.The final type ofxisint,as specified in classC.

The generated__init__method forCwill look like:

def__init__(self,x:int=15,y:int=0,z:int=10):

Default factory functions

If a field specifies adefault_factory,it is called with zero arguments when a default value for the field is needed. For example, to create a new instance of a list, use:

l:list=field(default_factory=list)

If a field is excluded from__init__(usinginit=False) and the field also specifiesdefault_factory,then the default factory function will always be called from the generated__init__ function. This happens because there is no other way to give the field an initial value.

Mutable default values

Python stores default member variable values in class attributes. Consider this example, not using Data Classes:

classC:
x=[]
defadd(self,element):
self.x+=element

o1=C()
o2=C()
o1.add(1)
o2.add(2)
asserto1.x==[1,2]
asserto1.xiso2.x

Note that the two instances of classCshare the same class variablex,as expected.

Using Data Classes,ifthis code was valid:

@dataclass
classD:
x:List=[]
defadd(self,element):
self.x+=element

it would generate code similar to:

classD:
x=[]
def__init__(self,x=x):
self.x=x
defadd(self,element):
self.x+=element

assertD().xisD().x

This has the same issue as the original example using classC. That is, two instances of classDthat do not specify a value for xwhen creating a class instance will share the same copy of x.Because Data Classes just use normal Python class creation they also share this problem. There is no general way for Data Classes to detect this condition. Instead, Data Classes will raise a TypeErrorif it detects a default parameter of typelist, dict,orset.This is a partial solution, but it does protect against many common errors. SeeAutomatically support mutable default valuesin the Rejected Ideas section for more details.

Using default factory functions is a way to create new instances of mutable types as default values for fields:

@dataclass
classD:
x:list=field(default_factory=list)

assertD().xisnotD().x

Module level helper functions

• fields(class_or_instance):Returns a tuple ofFieldobjects that define the fields for this Data Class. Accepts either a Data Class, or an instance of a Data Class. RaisesValueErrorif not passed a Data Class or instance of one. Does not return pseudo-fields which areClassVarorInitVar.
• asdict(instance,*,dict_factory=dict):Converts the Data Class instanceto a dict (by using the factory function dict_factory). Each Data Class is converted to a dict of its fields, as name:value pairs. Data Classes, dicts, lists, and tuples are recursed into. For example:

  @dataclass
  classPoint:
  x:int
  y:int
  
  @dataclass
  classC:
  l:List[Point]
  
  p=Point(10,20)
  assertasdict(p)=={'x':10,'y':20}
  
  c=C([Point(0,0),Point(10,4)])
  assertasdict(c)=={'l':[{'x':0,'y':0},{'x':10,'y':4}]}
  

  RaisesTypeErrorifinstanceis not a Data Class instance.

• astuple(*,tuple_factory=tuple):Converts the Data Class instanceto a tuple (by using the factory function tuple_factory). Each Data Class is converted to a tuple of its field values. Data Classes, dicts, lists, and tuples are recursed into.

  Continuing from the previous example:

  assertastuple(p)==(10,20)
  assertastuple(c)==([(0,0),(10,4)],)
  

  RaisesTypeErrorifinstanceis not a Data Class instance.

• make_dataclass(cls_name,fields,*,bases=(),namespace=None): Creates a new Data Class with namecls_name,fields as defined infields,base classes as given inbases,and initialized with a namespace as given innamespace.fieldsis an iterable whose elements are eithername,(name,type),or (name,type,Field).If justnameis supplied, typing.Anyis used fortype.This function is not strictly required, because any Python mechanism for creating a new class with __annotations__can then apply thedataclassfunction to convert that class to a Data Class. This function is provided as a convenience. For example:

  C=make_dataclass('C',
  [('x',int),
  'y',
  ('z',int,field(default=5))],
  namespace={'add_one':lambdaself:self.x+1})
  

  Is equivalent to:

  @dataclass
  classC:
  x:int
  y:'typing.Any'
  z:int=5
  
  defadd_one(self):
  returnself.x+1
  

• replace(instance,**changes):Creates a new object of the same type ofinstance,replacing fields with values fromchanges. Ifinstanceis not a Data Class, raisesTypeError.If values inchangesdo not specify fields, raisesTypeError.

  The newly returned object is created by calling the__init__ method of the Data Class. This ensures that __post_init__,if present, is also called.

  Init-only variables without default values, if any exist, must be specified on the call toreplaceso that they can be passed to __init__and__post_init__.

  It is an error forchangesto contain any fields that are defined as havinginit=False.AValueErrorwill be raised in this case.

  Be forewarned about howinit=Falsefields work during a call to replace().They are not copied from the source object, but rather are initialized in__post_init__(),if they’re initialized at all. It is expected thatinit=Falsefields will be rarely and judiciously used. If they are used, it might be wise to have alternate class constructors, or perhaps a custom replace()(or similarly named) method which handles instance copying.

• is_dataclass(class_or_instance):Returns True if its parameter is a dataclass or an instance of one, otherwise returns False.

  If you need to know if a class is an instance of a dataclass (and not a dataclass itself), then add a further check fornot isinstance(obj,type):

  defis_dataclass_instance(obj):
  returnis_dataclass(obj)andnotisinstance(obj,type)
  

python-ideas discussion

This discussion started on python-ideas[9]and was moved to a GitHub repo[10]for further discussion. As part of this discussion, we made the decision to usePEP 526syntax to drive the discovery of fields.

Support for automatically setting__slots__?

At least for the initial release,__slots__will not be supported. __slots__needs to be added at class creation time. The Data Class decorator is called after the class is created, so in order to add__slots__the decorator would have to create a new class, set __slots__,and return it. Because this behavior is somewhat surprising, the initial version of Data Classes will not support automatically setting__slots__.There are a number of workarounds:

• Manually add__slots__in the class definition.
• Write a function (which could be used as a decorator) that inspects the class usingfields()and creates a new class with __slots__set.

For more discussion, see[11].

Why not just use namedtuple?

• Any namedtuple can be accidentally compared to any other with the same number of fields. For example:Point3D(2017,6,2)== Date(2017,6,2).With Data Classes, this would return False.
• A namedtuple can be accidentally compared to a tuple. For example, Point2D(1,10)==(1,10).With Data Classes, this would return False.
• Instances are always iterable, which can make it difficult to add fields. If a library defines:

  Time=namedtuple('Time',['hour','minute'])
  defget_time():
  returnTime(12,0)
  

  Then if a user uses this code as:

  hour,minute=get_time()
  

  then it would not be possible to add asecondfield toTime without breaking the user’s code.

• No option for mutable instances.
• Cannot specify default values.
• Cannot control which fields are used for__init__,__repr__, etc.
• Cannot support combining fields by inheritance.

Why not just use typing.NamedTuple?

For classes with statically defined fields, it does support similar syntax to Data Classes, using type annotations. This produces a namedtuple, so it sharesnamedtuples benefits and some of its downsides. Data Classes, unliketyping.NamedTuple,support combining fields via inheritance.

Why not just use attrs?

• attrs moves faster than could be accommodated if it were moved in to the standard library.
• attrs supports additional features not being proposed here: validators, converters, metadata, etc. Data Classes makes a tradeoff to achieve simplicity by not implementing these features.

For more discussion, see[12].

post-init parameters

In an earlier version of this PEP beforeInitVarwas added, the post-init function__post_init__never took any parameters.

The normal way of doing parameterized initialization (and not just with Data Classes) is to provide an alternate classmethod constructor. For example:

@dataclass
classC:
x:int

@classmethod
deffrom_file(cls,filename):
withopen(filename)asfl:
file_value=int(fl.read())
returnC(file_value)

c=C.from_file('file.txt')

Because the__post_init__function is the last thing called in the generated__init__,having a classmethod constructor (which can also execute code immediately after constructing the object) is functionally equivalent to being able to pass parameters to a __post_init__function.

WithInitVars,__post_init__functions can now take parameters. They are passed first to__init__which passes them to__post_init__where user code can use them as needed.

The only real difference between alternate classmethod constructors andInitVarpseudo-fields is in regards to required non-field parameters during object creation. WithInitVars, using __init__and the module-levelreplace()functionInitVars must always be specified. Consider the case where acontext object is needed to create an instance, but isn’t stored as a field. With alternate classmethod constructors thecontextparameter is always optional, because you could still create the object by going through__init__(unless you suppress its creation). Which approach is more appropriate will be application-specific, but both approaches are supported.

Another reason for usingInitVarfields is that the class author can control the order of__init__parameters. This is especially important with regular fields andInitVarfields that have default values, as all fields with defaults must come after all fields without defaults. A previous design had all init-only fields coming after regular fields. This meant that if any field had a default value, then all init-only fields would have to have defaults values, too.

asdict and astuple function names

The names of the module-level helper functionsasdict()and astuple()are arguably notPEP 8compliant, and should be as_dict()andas_tuple(),respectively. However, after discussion[13]it was decided to keep consistency with namedtuple._asdict()andattr.asdict().

Copyinginit=Falsefields after new object creation in replace()

Fields that areinit=Falseare by definition not passed to __init__,but instead are initialized with a default value, or by calling a default factory function in__init__,or by code in __post_init__.

A previous version of this PEP specified thatinit=Falsefields would be copied from the source object to the newly created object after__init__returned, but that was deemed to be inconsistent with using__init__and__post_init__to initialize the new object. For example, consider this case:

@dataclass
classSquare:
length:float
area:float=field(init=False,default=0.0)

def__post_init__(self):
self.area=self.length*self.length

s1=Square(1.0)
s2=replace(s1,length=2.0)

Ifinit=Falsefields were copied from the source to the destination object after__post_init__is run, then s2 would end up beginSquare(length=2.0,area=1.0),instead of the correct Square(length=2.0,area=4.0).

Automatically support mutable default values

One proposal was to automatically copy defaults, so that if a literal list[]was a default value, each instance would get a new list. There were undesirable side effects of this decision, so the final decision is to disallow the 3 known built-in mutable types: list, dict, and set. For a complete discussion of this and other options, see[14].

Custom __init__ method

Sometimes the generated__init__method does not suffice. For example, suppose you wanted to have an object to store*argsand **kwargs:

@dataclass(init=False)
classArgHolder:
args:List[Any]
kwargs:Mapping[Any,Any]

def__init__(self,*args,**kwargs):
self.args=args
self.kwargs=kwargs

a=ArgHolder(1,2,three=3)

A complicated example

This code exists in a closed source project:

classApplication:
def__init__(self,name,requirements,constraints=None,path='',executable_links=None,executables_dir=()):
self.name=name
self.requirements=requirements
self.constraints={}ifconstraintsisNoneelseconstraints
self.path=path
self.executable_links=[]ifexecutable_linksisNoneelseexecutable_links
self.executables_dir=executables_dir
self.additional_items=[]

def__repr__(self):
returnf'Application({self.name!r},{self.requirements!r},{self.constraints!r},{self.path!r},{self.executable_links!r},{self.executables_dir!r},{self.additional_items!r})'

This can be replaced by:

@dataclass
classApplication:
name:str
requirements:List[Requirement]
constraints:Dict[str,str]=field(default_factory=dict)
path:str=''
executable_links:List[str]=field(default_factory=list)
executable_dir:Tuple[str]=()
additional_items:List[str]=field(init=False,default_factory=list)

The Data Class version is more declarative, has less code, supports typing,and includes the other generated functions.