C-like structures in Python

Question

Is there a way to conveniently define a C-like structure in Python  I m tired of writing stuff like   class MyStruct        def   init   self  field1  field2  field3           self field1   field1         self field2   field2         self field3   field3

User · Answer

Perhaps you are looking for Structs without constructors   class Sample    name        average   0 0   values   None   list cannot be initialized here    s1   Sample   s1 name    sample 1  s1 values      s1 values append 1  s1 values append 2  s1 values append 3   s2   Sample   s2 name    sample 2  s2 values      s2 values append 4   for v in s1 values      prints 1 2 3 -- gt  OK    print v print       for v in s2 values      prints 4 -- gt  OK    print v

User · Answer

There is a python package exactly for this purpose  see cstruct2py  cstruct2py is a pure python library for generate python classes from C code and use them to pack and unpack data  The library can parse C headres  structs  unions  enums  and arrays declarations  and emulate them in python  The generated pythonic classes can parse and pack the data   For example   typedef struct     int x    int y    Point   after generating pythonic class    p   Point x 0x1234  y 0x5678  p packed      x34 x12 x00 x00 x78 x56 x00 x00       How to use   First we need to generate the pythonic structs   import cstruct2py parser   cstruct2py c2py Parser   parser parse file  examples example h     Now we can import all names from the C code   parser update globals globals      We can also do that directly   A   parser parse string  struct A   int x  int y        Using types and defines from the C code  a   A   a x   45 print a buf   a packed b   A buf  print b c   A  aaaa11112222   2  print c print repr c    The output will be     x  0x2d   y  0x0    x  0x2d   y  0x0    x  0x31316161   y  0x32323131  A  aa111122   x 0x31316161  y 0x32323131       Clone   For clone cstruct2py run   git clone https   github com st0ky cstruct2py git --recursive

User · Answer

You can also pass the init parameters to the instance variables by position    Abstract struct class        class Struct      def   init    self   argv    argd           if len argd                 Update by dictionary             self   dict   update  argd          else                Update by position             attrs   filter  lambda x  x 0 2           dir self               for n in range len argv                    setattr self  attrs n   argv n      Specific class class Point3dStruct  Struct       x   0     y   0     z   0  pt1   Point3dStruct   pt1 x   10  print pt1 x print  -  10  pt2   Point3dStruct 5  6   print pt2 x  pt2 y print  -  10  pt3   Point3dStruct  x 1  y 2  z 3  print pt3 x  pt3 y  pt3 z print  -  10

User · Answer

I wrote a decorator which you can use on any method to make it so that all of the arguments passed in  or any defaults  are assigned to the instance   def argumentsToAttributes method       argumentNames   method func code co varnames 1          Generate a dictionary of default values      defaultsDict          defaults   method func defaults if method func defaults else        for i  default in enumerate defaults  start   len argumentNames  - len defaults            defaultsDict argumentNames i     default      def newMethod self   args    kwargs             Use the positional arguments          for name  value in zip argumentNames  args               setattr self  name  value             Add the key word arguments  If anything is missing  use the default          for name in argumentNames len args                 setattr self  name  kwargs get name  defaultsDict name               Run whatever else the method needs to do          method self   args    kwargs       return newMethod   A quick demonstration  Note that I use a positional argument a  use the default value for b  and a named argument c  I then print all 3 referencing self  to show that they ve been properly assigned before the method is entered   class A object        argumentsToAttributes     def   init   self  a  b    Invisible   c    Hello            print self a          print self b          print self c   A  Why   c    Nothing     Note that my decorator should work with any method  not just   init

User · Answer

You can use a tuple for a lot of things where you would use a struct in C  something like x y coordinates or RGB colors for example    For everything else you can use dictionary  or a utility class like this one    gt  gt  gt  class Bunch          def   init   self    kwds               self   dict   update kwds       gt  gt  gt  mystruct   Bunch field1 value1  field2 value2    I think the  definitive  discussion is here  in the published version of the Python Cookbook

User · Answer

I think Python structure dictionary is suitable for this requirement   d   dict   d field1    field1 d field2    field2 d field2    field3

User · Answer

The best way I found to do this was to use a custom dictionary class as explained in this post  https   stackoverflow com a 14620633 8484485  If iPython autocompletion support is needed  simply define the dir   function like this   class AttrDict dict       def   init   self   args    kwargs           super AttrDict  self    init    args    kwargs          self   dict     self     def   dir   self           return self keys     You then define your pseudo struct like so   this one is nested   my struct AttrDict         com1  AttrDict             inst   0x05            numbytes  2           canpayload  False           payload  None             You can then access the values inside my struct like this   print my struct com1 inst      5

User · Answer

Whenever I need an  instant data object that also behaves like a dictionary   I don t think of C structs    I think of this cute hack   class Map dict       def   init   self    kwargs           super Map  self    init     kwargs          self   dict     self   Now you can just say   struct   Map field1  foo   field2  bar   field3 42   self assertEquals  bar   struct field2  self assertEquals 42  struct  field3      Perfectly handy for those times when you need a  data bag that s NOT a class   and for when namedtuples are incomprehensible

User · Answer

You can subclass the C structure that is available in the standard library  The ctypes module provides a Structure class  The example from the docs    gt  gt  gt  from ctypes import    gt  gt  gt  class POINT Structure            fields       x   c int                         y   c int        gt  gt  gt  point   POINT 10  20   gt  gt  gt  print point x  point y 10 20  gt  gt  gt  point   POINT y 5   gt  gt  gt  print point x  point y 0 5  gt  gt  gt  POINT 1  2  3  Traceback  most recent call last     File   lt stdin gt    line 1  in   ValueError  too many initializers  gt  gt  gt   gt  gt  gt  class RECT Structure            fields       upperleft   POINT                         lowerright   POINT        gt  gt  gt  rc   RECT point   gt  gt  gt  print rc upperleft x  rc upperleft y 0 5  gt  gt  gt  print rc lowerright x  rc lowerright y 0 0  gt  gt  gt

User · Answer

dF  that s pretty cool    I didn t   know that I could access the fields in   a class using dict       Mark  the situations that I wish I had   this are precisely when I want a tuple   but nothing as  heavy  as a   dictionary    You can access the fields of a class using a dictionary because the fields of a class  its methods and all its properties are stored internally using dicts  at least in CPython       Which leads us to your second comment  Believing that Python dicts are  heavy  is an extremely non-pythonistic concept  And reading such comments kills my Python Zen  That s not good   You see  when you declare a class you are actually creating a pretty complex wrapper around a dictionary - so  if anything  you are adding more overhead than by using a simple dictionary  An overhead which  by the way  is meaningless in any case  If you are working on performance critical applications  use C or something

User · Answer

I don t see this answer here  so I figure I ll add it since I m leaning Python right now and just discovered it  The Python tutorial  Python 2 in this case  gives the following simple and effective example   class Employee      pass  john   Employee      Create an empty employee record    Fill the fields of the record john name    John Doe  john dept    computer lab  john salary   1000   That is  an empty class object is created  then instantiated  and the fields are added dynamically   The up-side to this is its really simple  The downside is it isn t particularly self-documenting  the intended members aren t listed anywhere in the class  definition    and unset fields can cause problems when accessed  Those two problems can be solved by   class Employee      def   init    self           self name   None   or whatever         self dept   None         self salary   None   Now at a glance you can at least see what fields the program will be expecting   Both are prone to typos  john slarly   1000 will succeed  Still  it works

User · Answer

You access C-Style struct in python in following way   class cstruct      var i   0     var f   0 0     var str        if you just want use object of cstruct  obj   cstruct   obj var i   50 obj var f   50 00 obj var str    fifty  print  cstruct  obj i  d f  f s  s    obj var i  obj var f  obj var str    if you want to create an array of objects of cstruct  obj array    cstruct   for i in range 10   obj array 0  var i   10 obj array 0  var f   10 00 obj array 0  var str    ten    go ahead and fill rest of array instaces of struct   print all the value for i in range 10       print  cstruct  obj array i  d f  f s  s    obj array i  var i  obj array i  var f  obj array i  var str    Note  instead of  cstruct  name  please use your struct name instead of var i  var f  var str  please define your structure s member variable

User · Answer

This might be a bit late but I made a solution using Python Meta-Classes  decorator version below too    When   init   is called during run time  it grabs each of the arguments and their value and assigns them as instance variables to your class  This way you can make a struct-like class without having to assign every value manually   My example has no error checking so it is easier to follow   class MyStruct type       def   call   cls   args    kwargs           names   cls   init   func code co varnames 1            self   type   call   cls   args    kwargs           for name  value in zip names  args               setattr self   name  value           for name  value in kwargs iteritems                setattr self   name  value          return self    Here it is in action    gt  gt  gt  class MyClass object         metaclass     MyStruct     def   init   self  a  b  c           pass    gt  gt  gt  my instance   MyClass 1  2  3   gt  gt  gt  my instance a 1  gt  gt  gt     I posted it on reddit and  u matchu posted a decorator version which is cleaner  I d encourage you to use it unless you want to expand the metaclass version    gt  gt  gt  def init all args fn        wraps fn      def wrapped init self   args    kwargs           names   fn func code co varnames 1            for name  value in zip names  args               setattr self  name  value           for name  value in kwargs iteritems                setattr self  name  value       return wrapped init   gt  gt  gt  class Test object        init all args     def   init   self  a  b           pass    gt  gt  gt  a   Test 1  2   gt  gt  gt  a a 1  gt  gt  gt

User · Answer

Personally  I like this variant too  It extends  dF s answer   class struct      def   init   self   sequential    named           fields   dict zip sequential   None  len sequential      named          self   dict   update fields      def   repr   self           return str self   dict      It supports two modes of initialization  that can be blended      Struct with field1  field2  field3 that are initialized to None  mystruct1   struct  field1    field2    field3      Struct with field1  field2  field3 that are initialized according to arguments  mystruct2   struct field1 1  field2 2  field3 3    Also  it prints nicer    print mystruct2    Prints    field3   3   field1   1   field2   2

User · Answer

Update  Data Classes  With the introduction of Data Classes in Python 3 7 we get very close    The following example is similar to the NamedTuple example below  but the resulting object is mutable and it allows for default values   from dataclasses import dataclass    dataclass class Point      x  float     y  float     z  float   0 0   p   Point 1 5  2 5   print p     Point x 1 5  y 2 5  z 0 0    This plays nicely with the new typing module in case you want to use more specific type annotations   I ve been waiting desperately for this  If you ask me  Data Classes and the new NamedTuple declaration  combined with the typing module are a godsend   Improved NamedTuple declaration  Since Python 3 6 it became quite simple and beautiful  IMHO   as long as you can live with immutability   A new way of declaring NamedTuples was introduced  which allows for type annotations as well   from typing import NamedTuple   class User NamedTuple       name  str   class MyStruct NamedTuple       foo  str     bar  int     baz  list     qux  User   my item   MyStruct  foo   0    baz    User  peter     print my item    MyStruct foo  foo   bar 0  baz   baz    qux User name  peter

User · Answer

Use a named tuple  which was added to the collections module in the standard library in Python 2 6  It s also possible to use Raymond Hettinger s named tuple recipe if you need to support Python 2 4   It s nice for your basic example  but also covers a bunch of edge cases you might run into later as well  Your fragment above would be written as   from collections import namedtuple MyStruct   namedtuple  MyStruct    field1 field2 field3     The newly created type can be used like this   m   MyStruct  foo    bar    baz     You can also use named arguments   m   MyStruct field1  foo   field2  bar   field3  baz

User · Answer

Here is a quick and dirty trick    gt  gt  gt  ms   Warning    gt  gt  gt  ms foo   123  gt  gt  gt  ms bar    akafrit    How does it works  It just re-use the builtin class Warning  derived from Exception  and use it as it was you own defined class   The good points are that you do not need to import or define anything first  that  Warning  is a short name  and that it also makes clear you are doing something dirty which should not be used elsewhere than a small script of yours   By the way  I tried to find something even simpler like ms   object   but could not  this last exemple is not working   If you have one  I am interested

User · Answer

https   stackoverflow com a 32448434 159695 does not work in Python3   https   stackoverflow com a 35993 159695 works in Python3   And I extends it to add default values   class myStruct      def   init   self    kwds           self x 0         self   dict   update kwds    Must be last to accept assigned member variable      def   repr   self           args      s  s     k  repr v   for  k v  in vars self  items            return   s  s       self   class     qualname         join args     a myStruct   b myStruct x 3 y  test   c myStruct x  str     gt  gt  gt  a myStruct x 0   gt  gt  gt  b myStruct x 3  y  test    gt  gt  gt  c myStruct x  str

User · Answer

How about a dictionary   Something like this   myStruct     field1    some val    field2    some val     Then you can use this to manipulate values   print myStruct  field1   myStruct  field2      some other values    And the values don t have to be strings   They can be pretty much any other object

User · Answer

Some the answers here are massively elaborate  The simplest option I ve found is  from  http   norvig com python-iaq html    class Struct       A structure that can have any fields defined       def   init   self    entries   self   dict   update entries    Initialising    gt  gt  gt  options   Struct answer 42  linelen 80  font  courier    gt  gt  gt  options answer 42   adding more    gt  gt  gt  options cat    dog   gt  gt  gt  options cat dog   edit  Sorry didn t see this example already further down

User · Answer

The following solution to a struct is inspired by the namedtuple implementation and some of the previous answers  However  unlike the namedtuple it is mutable  in it s values  but like the c-style struct immutable in the names attributes  which a normal class or dict isn t    class template        class  typename   def   init   self   args    kwargs       fields    field names r       for x in fields          setattr self  x  None                   for name  value in zip fields  args           setattr self  name  value       for name  value in kwargs items            setattr self  name  value               def   repr   self       return str vars self    def   setattr   self  name  value       if name not in  field names r           raise KeyError  invalid name   s    name      object   setattr   self  name  value                   def struct typename  field names        class definition    class template format          typename   typename          field names   field names       namespace   dict   name    struct  s    typename      exec class definition  namespace      result   namespace typename      result  source   class definition      return result   Usage   Person   struct  Person     firstname   lastname    generic   Person   michael   Person  Michael   jones   Person lastname    Jones     In  168   michael middlename    ben  Traceback  most recent call last      File   lt ipython-input-168-b31c393c0d67 gt    line 1  in  lt module gt  michael middlename    ben     File   lt string gt    line 19  in   setattr    KeyError   invalid name  middlename

User · Answer

If you don t have a 3 7 for  dataclass and need mutability  the following code might work for you  It s quite self-documenting and IDE-friendly  auto-complete   prevents writing things twice  is easily extendable and it is very simple to test that all instance variables are completely initialized   class Params        def   init   self           self var1   int   None         self var2   str   None      def are all defined self           for key  value in self   dict   items                assert  value is not None    instance variable    is still None  format key          return True   params   Params   params var1   2 params var2    hello  assert params are all defined

User · Answer

I would also like to add a solution that uses slots   class Point        slots       x    y       def   init   self  x  y           self x   x         self y   y   Definitely check the documentation for slots but a quick explanation of slots is that it is python s way of saying   If you can lock these attributes and only these attributes into the class such that you commit that you will not add any new attributes once the class is instantiated  yes you can add new attributes to a class instance  see example below  then I will do away with the large memory allocation that allows for adding new attributes to a class instance and use just what I need for these slotted attributes    Example of adding attributes to class instance  thus not using slots    class Point      def   init   self  x  y           self x   x         self y   y  p1   Point 3 5  p1 z   8 print p1 z    Output  8  Example of trying to add attributes to class instance where slots was used   class Point        slots       x    y       def   init   self  x  y           self x   x         self y   y  p1   Point 3 5  p1 z   8   Output  AttributeError   Point  object has no attribute  z   This can effectively works as a struct and uses less memory than a class  like a struct would  although I have not researched exactly how much   It is recommended to use slots if you will be creating a large amount of instances of the object and do not need to add attributes  A point object is a good example of this as it is likely that one may instantiate many points to describe a dataset

User · Answer

NamedTuple is comfortable  but there no one shares the performance and storage   from typing import NamedTuple import guppy    pip install guppy import timeit   class User      def   init   self  name  str  uid  int           self name   name         self uid   uid   class UserSlot        slots       name    uid        def   init   self  name  str  uid  int           self name   name         self uid   uid   class UserTuple NamedTuple           slots           AttributeError  Cannot overwrite NamedTuple attribute   slots       name  str     uid  int   def get fn obj  attr name  str       def get            getattr obj  attr name      return get   if  memory test       obj    User  Carson   1  for   in range 1000000          Cumulative  189138883     obj slot    UserSlot  Carson   1  for   in range 1000000              77718299   lt -- winner     obj namedtuple    UserTuple  Carson   1  for   in range 1000000       85718297     print guppy hpy   heap       Run this function individually               Index  Count         Size     Cumulative    Kind  class   dict of class       0 1000000    24 112000000 34 112000000  34 dict of   main   User      1 1000000    24 64000000  19 176000000  53   main   UserTuple      2 1000000    24 56000000  17 232000000  70   main   User      3 1000000    24 56000000  17 288000000  87   main   UserSlot                   if  performance test       obj   User  Carson   1      obj slot   UserSlot  Carson   1      obj tuple   UserTuple  Carson   1       time normal   min timeit repeat get fn obj   name    repeat 20       print time normal     0 12550550000000005      time slot   min timeit repeat get fn obj slot   name    repeat 20       print time slot     0 1368690000000008      time tuple   min timeit repeat get fn obj tuple   name    repeat 20       print time tuple     0 16006120000000124      print time tuple time slot     1 1694481584580898    The slot is almost 17  faster than NamedTuple on Windows   Python 3 7 7     If your   dict   is not using  please choose between   slots    higher performance and storage  and NamedTuple  clear for reading and use   You can review this link Usage of slots   to get more   slots   information

User · Answer

Here is a solution which uses a class  never instantiated  to hold data   I like that this way involves very little typing and does not require any additional packages etc   class myStruct      field1    one      field2    2    You can add more fields later  as needed   myStruct field3   3   To get the values  the fields are accessed as usual    gt  gt  gt  myStruct field1  one

[python] C-like structures in Python

Examples related to python

Examples related to struct