How do I create a constant in Python

Question

Is there a way to declare a constant in Python  In Java we can create constant values in this manner   public static final String CONST NAME    Name     What is the equivalent of the above Java constant declaration in Python

User · Answer

You can wrap a constant in a numpy array, flag it write only, and always call it by index zero.

import numpy as np

# declare a constant
CONSTANT = 'hello'

# put constant in numpy and make read only
CONSTANT = np.array([CONSTANT])
CONSTANT.flags.writeable = False
# alternatively: CONSTANT.setflags(write=0)

# call our constant using 0 index    
print 'CONSTANT %s' % CONSTANT[0]

# attempt to modify our constant with try/except
new_value = 'goodbye'
try:
    CONSTANT[0] = new_value
except:
    print "cannot change CONSTANT to '%s' it's value '%s' is immutable" % (
        new_value, CONSTANT[0])

# attempt to modify our constant producing ValueError
CONSTANT[0] = new_value



>>>
CONSTANT hello
cannot change CONSTANT to 'goodbye' it's value 'hello' is immutable
Traceback (most recent call last):
  File "shuffle_test.py", line 15, in <module>
    CONSTANT[0] = new_value
ValueError: assignment destination is read-only

of course this only protects the contents of the numpy, not the variable "CONSTANT" itself; you can still do:

CONSTANT = 'foo'

and CONSTANT would change, however that would quickly throw an TypeError the first time CONSTANT[0] is later called in the script.

although... I suppose if you at some point changed it to

CONSTANT = [1,2,3]

now you wouldn't get the TypeError anymore. hmmmm....

https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.setflags.html

User · Answer

Edit  Added sample code for Python 3  Note  this other answer looks like it provides a much more complete implementation similar to the following  with more features    First  make a metaclass   class MetaConst type       def   getattr   cls  key           return cls key       def   setattr   cls  key  value           raise TypeError   This prevents statics properties from being changed  Then make another class that uses that metaclass   class Const object         metaclass     MetaConst      def   getattr   self  name           return self name       def   setattr   self  name  value           raise TypeError   Or  if you re using Python 3   class Const object  metaclass MetaConst       def   getattr   self  name           return self name       def   setattr   self  name  value           raise TypeError   This should prevent instance props from being changed  To use it  inherit   class MyConst Const       A   1     B   2   Now the props  accessed directly or via an instance  should be constant   MyConst A   1 my const   MyConst   my const A   1  MyConst A    changed    TypeError my const A    changed    TypeError   Here s an example of above in action  Here s another example for Python 3

User · Answer

from enum import Enum class StringConsts str Enum       ONE  one      TWO  two   print f Truth is   StringConsts ONE   one      Truth is True StringConsts ONE  one   Error  Cannot reassign   This mixin of Enum and str gives you the power of not having to reimplement setattr  through Enum  and comparison to other str objects  through str    This might deprecate http   code activestate com recipes 65207-constants-in-python  in user-97991 completely

User · Answer

I know this is an old question  but since new solutions are still being added to it  I d like to make the list of possible solutions even more complete  You could implement constants within instances through attribute access by inheriting from a class like the following    class ConstantError Exception       pass    maybe give nice error message  class AllowConstants       constants   None      class constants   None      def   init   self           self  constants              if self  class constants is not None              self  constants update self  class constants       def constant self  name  value           assert isinstance name  str          assert self  constants is not None   AllowConstants was not initialized          if name in self  constants or name in self   dict                raise ConstantError name          self  constants name    value      def   getattr   self  attr           if attr in self  constants              return self  constants attr          raise AttributeError attr       def   setattr   self  attr  val           if self  constants is None                not finished initialization             self   dict   attr    val         else              if attr in self  constants                  raise ConstantError attr              else                  self   dict   attr    val      def   dir   self           return super     dir       list self  constants keys       When subclassing this  constants you create will be protected   class Example AllowConstants       def   init   self  a  b           super     init             self constant  b   b          self a   a      def try a self  value           self a   value      def try b self  value           self b   value      def   str   self           return str   a   self a   b   self b        def   repr   self           return self   str       example   Example 1  2  print example       a   1   b   2   example try a 5  print example       a   5   b   2   example try b 6     ConstantError  b  example a   7 print example       a   7   b   2   example b   8    ConstantError  b  print hasattr example   b       True     To show that constants really do immediately become constant    class AnotherExample AllowConstants       def   init   self           super     init             self constant  a   2          print self a          self a 3   AnotherExample      2  ConstantError  a     finally  for class constants  class YetAnotherExample Example        class constants              BLA   3            def   init   self  a  b           super     init   a b       def try BLA self  value           self BLA   value  ex3   YetAnotherExample 10  20  ex3 BLA    3 ex3 try BLA 10     ConstantError  BLA ex3 BLA   4    ConstantError  BLA   Constants are local  every instance of classes inheriting from AllowConstants will have their own constants   act as normal attributes as long as they are not being re-assigned  and writing classes that inherit from this allows for more or less the same style as with languages that do support constants    Also  if you want to prevent anyone from changing the values by directly accessing instance  constants  you can use one of the many containers not allowing this that were suggested in other answers  Finally  if you really feel you need to  you could prevent people from setting all of instance  constants to a new dictionary through some more attribute access of AllowConstants   Of course none of this is very pythonic  but that s besides the point    Edit  since making python unpythonic is a fun game   In order to make inheritance a bit easier you could modify AllowConstants as follows   class AllowConstants       constants   None      class constants   None      def   init   self           self  constants              self  update class constants        def   init subclass   cls                       Without this  it is necessary to set  class constants in any subclass of any class that has class constants                     if cls  class constants is not None               prevent trouble where  class constants is not overwritten             possible cases   cls   mro   1 -1   0 will have cls and -1 will have object             for case in possible cases                  if cls  class constants is case  class constants                      cls  class constants   None                     break      def  update class constants self                       Help with the inheritance of class constants                     for superclass in self   class     mro                if hasattr superclass    class constants                    sccc   superclass  class constants                 if sccc is not None                      for key in sccc                          if key in self  constants                              raise ConstantError key                      self  constants update sccc       def constant self  name  value           assert isinstance name  str          assert self  constants is not None   AllowConstants was not initialized          if name in self  constants or name in self   dict                raise ConstantError name          self  constants name    value      def   getattr   self  attr           if attr in self  constants              return self  constants attr          raise AttributeError attr       def   setattr   self  attr  val           if self  constants is None                not finished initialization             self   dict   attr    val         else              if attr in self  constants                  raise ConstantError attr              else                  self   dict   attr    val      def   dir   self           return super     dir       list self  constants keys      That way you can just do   class Example AllowConstants        class constants              BLA   2           def   init   self  a  b           super     init             self constant  b   b          self a   a      def try a self  value           self a   value      def try b self  value           self b   value      def   str   self           return str   a   self a   b   self b        def   repr   self           return self   str       class ChildExample1 Example        class constants              BLI   88         class ChildExample2 Example        class constants              BLA   44         example   ChildExample1 2 3  print example BLA     2 example BLA   8    ConstantError BLA print example BLI     88 example BLI   8    ConstantError BLI  example   ChildExample2 2 3     ConstantError BLA

User · Answer

We can create a descriptor object   class Constant    def   init   self value None       self value   value   def   get   self instance owner       return self value   def   set   self instance value       raise ValueError  You can t change a constant     1  If we wanted to work with constants at the instance level then   class A    NULL   Constant     NUM   Constant 0xFF   class B    NAME   Constant  bar     LISTA   Constant  0 1  INFINITY      gt  gt  gt  obj A    gt  gt  gt  print obj NUM      gt  255  gt  gt  gt  obj NUM  100  Traceback  most recent call last   File   lt stdin gt    line 1  in  lt module gt  ValueError  You can t change a constant   2  if we wanted to create constants only at the class level  we could use a metaclass that serves as a container for our constants  our descriptor objects   all the classes that descend will inherit our constants  our descriptor objects  without any risk that can be modified     metaclass of my class Foo class FooMeta type   pass    class Foo class Foo metaclass FooMeta   pass    I create constants in my metaclass FooMeta NUM   Constant 0xff  FooMeta NAME   Constant  FOO     gt  gt  gt  Foo NUM      gt  255  gt  gt  gt  Foo NAME     gt   FOO   gt  gt  gt  Foo NUM   0    gt  ValueError  You can t change a constant   If I create a subclass of Foo  this class will inherit the constant without the possibility of modifying them  class Bar Foo   pass   gt  gt  gt  Bar NUM     gt  255  gt  gt  gt  Bar NUM   0     gt  ValueError  You can t change a constant

User · Answer

Maybe pconst library will help you  github      pip install pconst  from pconst import const const APPLE PRICE   100 const APPLE PRICE   200    Out  Constant value of  APPLE PRICE  is not editable

User · Answer

Python doesn t have constants   Perhaps the easiest alternative is to define a function for it    def MY CONSTANT        return 42   MY CONSTANT   now has all the functionality of a constant  plus some annoying braces

User · Answer

well   even though this is outdated  let me add my 2 cents here  -   class ConstDict dict       def   init   self   args    kwargs           super ConstDict  self    init    args    kwargs       def   setitem   self  key  value           if key in self              raise ValueError  Value  s already exists     key           super ConstDict  self    setitem   key  value    Instead of ValueError to break  you can prevent any update happening there  One advantage of this is that you can add constants dynamically in the program but you cannot change once a constant is set  Also you can add any rule or whatsoever before setting a constant something like key must be a string or a lower case string or upper case string and so on before setting the key   However  I do not see any importance of setting constants in Python  No optimizations can happen like in C and hence it is something that is not required  I guess

User · Answer

I would make a class that overrides the   setattr   method of the base object class and wrap my constants with that  note that I m using python 2 7   class const object       def   init   self  val           super const  self    setattr    value   val      def   setattr   self  name  val           raise ValueError  Trying to change a constant value   self    To wrap a string    gt  gt  gt  constObj   const  Try to change me    gt  gt  gt  constObj value  Try to change me   gt  gt  gt  constObj value    Changed  Traceback  most recent call last          ValueError  Trying to change a constant value  gt  gt  gt  constObj2   const   or not    gt  gt  gt  mutableObj   constObj value   constObj2 value  gt  gt  gt  mutableObj  just a string  Try to change me or not    It s pretty simple  but if you want to use your constants the same as you would a non-constant object  without using constObj value   it will be a bit more intensive  It s possible that this could cause problems  so it might be best to keep the  value to show and know that you are doing operations with constants  maybe not the most  pythonic  way though

User · Answer

In my case  I needed immutable bytearrays for an implementation of a crypto library containing many literal numbers I wanted to ensure were constant   This answer works but attempted reassignment of bytearray elements does not raise an error   def const func          implement const decorator        def fset self  val              attempting to set a const raises  ConstError             class ConstError TypeError                  special exception for const reassignment                pass          raise ConstError      def fget self              get a const            return func        return property fget  fset    class Consts object          contain all constants          const     def C1               reassignment to C1 fails silently            return bytearray fromhex  deadbeef         const     def pi               is immutable            return 3 141592653589793   Constants are immutable  but constant bytearray assignment fails silently    gt  gt  gt  c   Consts    gt  gt  gt  c pi   6 283185307179586     https   en wikipedia org wiki Tau  2 CF 80   Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt    File  consts py   line 9  in fset     raise ConstError   main   ConstError  gt  gt  gt  c C1 0    0  gt  gt  gt  c C1 0  222  gt  gt  gt  c C1 bytearray b  xde xad xbe xef     A more powerful  simple  and perhaps even more  pythonic  approach involves the use of memoryview objects  buffer objects in  lt   python-2 6    import sys  PY VER   sys version split   0  split       if int PY VER 0      2      if int PY VER 1    lt  6          raise NotImplementedError     elif int PY VER 1      6          memoryview   buffer  class ConstArray object          represent a constant bytearray        def   init   self  init                       create a hidden bytearray and expose a memoryview of that bytearray for         read-only use                     if int PY VER 1      6              self   array   bytearray init decode  hex            else              self   array   bytearray fromhex init           self array   memoryview self   array       def   str   self           return str self   array       def   getitem   self   args    kwargs          return self array   getitem    args    kwargs    ConstArray item assignment is a TypeError    gt  gt  gt  C1   ConstArray  deadbeef    gt  gt  gt  C1 0    0 Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  TypeError   ConstArray  object does not support item assignment  gt  gt  gt  C1 0  222

User · Answer

In Python  constants do not exist  but you can indicate that a variable is a constant and must not be changed by adding CONST  to the start of the variable name and stating that it is a constant in a comment   myVariable   0 CONST daysInWeek   7      This is a constant - do not change its value     CONSTANT daysInMonth   30   This is also a constant - do not change this value    Alternatively  you may create a function that acts like a constant   def CONST daysInWeek        return 7

User · Answer

A tuple technically qualifies as a constant  as a tuple will raise an error if you try to change one of its values  If you want to declare a tuple with one value  then place a comma after its only value  like this   my tuple    0    Or any other value        To check this variable s value  use something similar to this     if my tuple 0     0       Code goes here   If you attempt to change this value  an error will be raised

User · Answer

Simply you can just   STRING CONSTANT    hi  NUMBER CONSTANT   89   hope that makes everything much simpler

User · Answer

No there is not  You cannot declare a variable or value as constant in Python  Just don t change it  If you are in a class  the equivalent would be  class Foo object       CONST NAME    quot Name quot   if not  it is just CONST NAME    quot Name quot   But you might want to have a look at the code snippet Constants in Python by Alex Martelli   As of Python 3 8  there s a typing Final variable annotation that will tell static type checkers  like mypy  that your variable shouldn t be reassigned  This is the closest equivalent to Java s final  However  it does not actually prevent reassignment  from typing import Final  a  Final   1    Executes fine  but mypy will report an error if you run mypy on this  a   2

User · Answer

Here is an implementation of a  Constants  class  which creates instances with read-only  constant  attributes  E g  can use Nums PI to get a value that has been initialized as 3 14159  and Nums PI   22 raises an exception     ---------- Constants py ---------- class Constants object               Create objects with read-only  constant  attributes      Example          Nums   Constants ONE 1  PI 3 14159  DefaultWidth 100 0          print 10   Nums PI         print  ----- Following line is deliberate ValueError -----          Nums PI   22              def   init   self   args    kwargs           self  d   dict  args    kwargs       def   iter   self           return iter self  d       def   len   self           return len self  d         NOTE  This is only called if self lacks the attribute        So it does not interfere with get of  self  d   etc      def   getattr   self  name           return self  d name         ASSUMES       attribute is OK to set  Need this to initialize  self  d   etc       If use as keys  they won t be constant      def   setattr   self  name  value           if  name 0                       super Constants  self    setattr   name  value          else              raise ValueError  setattr while locked   self   if    name         main            Usage example      Nums   Constants ONE 1  PI 3 14159  DefaultWidth 100 0      print 10   Nums PI     print  ----- Following line is deliberate ValueError -----      Nums PI   22   Thanks to  MikeGraham  s FrozenDict  which I used as a starting point  Changed  so instead of Nums  ONE   the usage syntax is Nums ONE   And thanks to  Raufio s answer  for idea to override    setattr      Or for an implementation with more functionality  see  Hans meine  s named constants at GitHub

User · Answer

A better approach to creating constants in Python is to take inspiration from the excellent attrs library  which helps Python programmers create classes without boilerplate  The short-con package does the same for constants by providing a convenience wrapper around attr make class   Disclaimer  I am the author of short-con   Values can be declared explicitly via either a dict or kwargs  These examples do the same thing  The constants   function supports all features of the library  and cons   is a helper for simple kwarg-based usage  from short con import constants  cons  Pieces   constants  Pieces   dict king   0  queen   9  rook   5  bishop   3  knight   3  pawn   1   Pieces   cons  Pieces   king   0  queen   9  rook   5  bishop   3  knight   3  pawn   1   For situations when the values are the same as  or can be derived from  the attribute names  usage is even more compact  Just supply names as a space-delimited string  list  or tuple  NAMES    KING QUEEN ROOK BISHOP KNIGHT PAWN  xs   NAMES split    Pieces   constants  Pieces   NAMES         All of these do the same thing  Pieces   constants  Pieces   xs  Pieces   constants  Pieces   tuple xs    The name-based usages support a few stylistic conventions  uppercase or lowercase attribute names  along with enum-style values  The underlying values are directly accessible  unlike constants created by the built-in enum library  Pieces QUEEN          short-con usage Pieces QUEEN value    enum library usage  And the object is directly iterable and convertible to other collections  for name  value in Pieces      print name  value   d   dict Pieces  tups   list Pieces

User · Answer

All of the answers given are essentially of two types    Create some sort of object for which you can  create attributes which cannot be changed once defined  Use a convention  like writing constants in all UPPERCASE or  for Python 3 8  use the final qualifier to indicate that you intend one or more names to be a constant    They can be summarized as saying  you cannot do what you ask using Python    However  there is actually a way to create a module with true constants  The code to do so is rather involved  and I will only give an outline of what is needed to do as it is already available under an open source license    Use an import hook to enable the creation of a custom module  The versatile code I use for this is found here  Create a special dict which allows adding items that conform to your chosen pattern  for example  names in all UPPERCASE  only once and prevent such names to have their values changed  For this  you will need to define your own methods such as   setitem      delitem    etc   The code for such a dict  such as found in this file  which is over 250 lines  is approximately 100 lines long  The dict for a normal Python module cannot be modified  So  when creating the module  you need to execute the code in your special dict first  and then use its content to update the module s dict   To prevent modifications of the values of the contants from outside of the module  i e  monkeypatching   you can replace the   class   of the module by a custom one with the   setattr   and   delattr   method redefined    The documentation about this example can be found here   It probably should be updated to reflect the number of answers given to this question

User · Answer

There s no const keyword as in other languages  however it is possible to create a Property that has a  getter function  to read the data  but no  setter function  to re-write the data  This essentially protects the identifier from being changed   Here is an alternative implementation using class property   Note that the code is far from easy for a reader wondering about constants  See explanation below  def constant f       def fset self  value           raise TypeError     def fget self           return f       return property fget  fset   class  Const object        constant     def FOO            return 0xBAADFACE      constant     def BAR            return 0xDEADBEEF  CONST    Const    print CONST FOO   3131964110  CONST FOO   0   Traceback  most recent call last                   CONST FOO   0   TypeError  None   Code Explanation    Define a function constant that takes an expression  and uses it to construct a  getter  - a function that solely returns the value of the expression  The setter function raises a TypeError so it s read-only Use the constant function we just created as a decoration to quickly define read-only properties      And in some other more old-fashioned way    The code is quite tricky  more explanations below   class  Const object        apply     def FOO            def fset self  value               raise TypeError         def fget self               return 0xBAADFACE         return property   locals     CONST    Const    print CONST FOO   3131964110  CONST FOO   0   Traceback  most recent call last                   CONST FOO   0   TypeError  None   Note that the  apply decorator seems to be deprecated    To define the identifier FOO  firs define two functions  fset  fget - the names are at my choice   Then use the built-in property function to construct an object that can be  set  or  get   Note hat the property function s first two parameters are named fset and fget   Use the fact that we chose these very names for our own getter  amp  setter and create a keyword-dictionary using the     double asterisk  applied to all the local definitions of that scope to pass parameters to the property function

User · Answer

There s no perfect way to do this  As I understand it most programmers will just capitalize the identifier  so PI   3 142 can be readily understood to be a constant   On the otherhand  if you want something that actually acts like a constant  I m not sure you ll find it  With anything you do there will always be some way of editing the  constant  so it won t really be a constant  Here s a very simple  dirty example   def define name  value     if  name   str id name    not in globals        globals   name   str id name      value  def constant name     return globals   name   str id name     define  PI  3 142   print constant  PI      This looks like it will make a PHP-style constant   In reality all it takes for someone to change the value is this   globals    PI  str id  PI       3 1415   This is the same for all the other solutions you ll find on here - even the clever ones that make a class and redefine the set attribute method - there will always be a way around them  That s just how Python is   My recommendation is to just avoid all the hassle and just capitalize your identifiers  It wouldn t really be a proper constant but then again nothing would

User · Answer

You can use Tuple for constant variable         A tuple is a collection which is ordered and unchangeable my tuple    1   quot Hello quot   3 4  print my tuple 0

User · Answer

You can emulate constant variables with help of the next class  An example of usage     Const const   Const   add two 2  three 3   print  const two     const two print  const three     const three  const add four 4   print  const four     const four   const four   5   a error here  four is a constant  const add six 6   print  const six     const six  const2   Const   add five 5    creating a new namespace with Const   print  const2 five     const2 five  print  const2 four     const2 four   a error here  four does not exist in const2 namespace  const2 add five 26    Call the constructor when you want to start a new constant namespace  Note that the class is under protection from unexpected modifying sequence type constants when Martelli s const class is not   The source is below   from copy import copy  class Const object    A class to create objects with constant fields    def   init   self       object   setattr   self    names         def add self    nameVals       for name  val in nameVals iteritems                      if hasattr self  name               raise ConstError  A field with a name    s   is already exist in Const class     name           setattr self  name  copy val     set up getter          self  names append name       return self   def   setattr   self  name  val       if name in self  names          raise ConstError  You cannot change a value of a stored constant         object   setattr   self  name  val

User · Answer

You can use a namedtuple as a workaround to effectively create a constant that works the same way as a static final variable in Java  a Java  constant    As workarounds go  it s sort of elegant   A more elegant approach would be to simply improve the Python language --- what sort of language lets you redefine math pi  -- but I digress     As I write this  I realize another answer to this question mentioned namedtuple  but I ll continue here because I ll show a syntax that more closely parallels what you d expect in Java  as there is no need to create a named type as namedtuple forces you to do    Following your example  you ll remember that in Java we must define the constant inside some class  because you didn t mention a class name  let s call it Foo  Here s the Java class   public class Foo     public static final String CONST NAME    Name       Here s the equivalent Python   from collections import namedtuple Foo   namedtuple   Foo    CONST NAME    Name     The key point I want to add here is that you don t need a separate Foo type  an  anonymous named tuple  would be nice  even though that sounds like an oxymoron   so we name our namedtuple  Foo so that hopefully it won t escape to importing modules   The second point here is that we immediately create an instance of the nametuple  calling it Foo  there s no need to do this in a separate step  unless you want to   Now you can do what you can do in Java    gt  gt  gt  Foo CONST NAME  Name    But you can t assign to it    gt  gt  gt  Foo CONST NAME    bar      AttributeError  can t set attribute   Acknowledgement  I thought I invented the namedtuple approach  but then I see that someone else gave a similar  although less compact  answer  Then I also noticed What are  quot named tuples quot  in Python   which points out that sys version info is now a namedtuple  so perhaps the Python standard library already came up with this idea much earlier   Note that unfortunately  this still being Python   you can erase the entire Foo assignment altogether    gt  gt  gt  Foo    bar     facepalm   But at least we re preventing the Foo CONST NAME value from being changed  and that s better than nothing  Good luck

User · Answer

Extending Raufio s answer  add a   repr   to return the value   class const object       def   init   self  val           super const  self    setattr    value   val      def   setattr   self  name  val           raise ValueError  Trying to change a constant value   self      def   repr   self           return    0   format self value    dt   const float 0 01   print dt   then the object behaves a little more like you might expect  you can access it directly rather then   value

User · Answer

I write a util lib for python const   kkconst - pypi  support str  int  float  datetime   the const field instance will keep its base type behavior   For example   from   future   import print function from kkconst import       BaseConst      ConstFloatField     class MathConst BaseConst       PI   ConstFloatField 3 1415926  verbose name u Pi       E   ConstFloatField 2 7182818284  verbose name u mathematical constant      Euler s number      GOLDEN RATIO   ConstFloatField 0 6180339887  verbose name u Golden Ratio    magic num   MathConst GOLDEN RATIO assert isinstance magic num  ConstFloatField  assert isinstance magic num  float   print magic num     0 6180339887 print magic num verbose name     Golden Ratio   more details usage you can read the pypi url    pypi  or  github

User · Answer

You can use StringVar or IntVar  etc  your constant is const val  val    Stackoverflow  const val   StringVar val  const trace  w   reverse   def reverse  args       const val set val

User · Answer

You can do it with collections namedtuple and itertools   import collections import itertools def Constants Name   Args    Kwargs     t   collections namedtuple Name  itertools chain Args  Kwargs keys       return t  itertools chain Args  Kwargs values       gt  gt  gt  myConstants   Constants  MyConstants    One    Two   Three    Four    gt  gt  gt  print myConstants One One  gt  gt  gt  print myConstants Two Two  gt  gt  gt  print myConstants Three Four  gt  gt  gt  myConstants One    Two  Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  AttributeError  can t set attribute

User · Answer

Python dictionaries are mutable  so they don t seem like a good way to declare constants    gt  gt  gt  constants     foo  1   bar  2   gt  gt  gt  print constants   foo   1   bar   2   gt  gt  gt  constants  bar     3  gt  gt  gt  print constants   foo   1   bar   3

User · Answer

The Pythonic way of declaring  constants  is basically a module level variable   RED   1 GREEN   2 BLUE   3   And then write your classes or functions  Since constants are almost always integers  and they are also immutable in Python  you have a very little chance of altering it   Unless  of course  if you explicitly set RED   2

User · Answer

Here it is a collection of idioms that I created as an attempt to improve some of the already available answers  I know the use of constant is not pythonic  and you should not do this at home  However  Python is such a dynamic language  This forum shows how it is possible the creation of constructs that looks and feels like constants  This answer has as the primary purpose to explore what can be expressed by the language  Please do not be too harsh with me  -   For more details I wrote a accompaniment blog about these idioms  In this post  I will call a constant variable to a constant reference to values  immutable or otherwise   Moreover  I say that a variable has a frozen value when it references a mutable object that a client-code cannot update its value s   A space of constants  SpaceConstants  This idiom creates what looks like a namespace of constant variables  a k a  SpaceConstants   It is a modification of a code snippet by Alex Martelli to avoid the use of module objects  In particular  this modification uses what I call a class factory because within SpaceConstants function  a class called SpaceConstants is defined  and an instance of it is returned  I explored the use of class factory to implement a policy-based design look-alike in Python in stackoverflow and also in a blogpost  def SpaceConstants        def setattr self  name  value           if hasattr self  name               raise AttributeError                   quot Cannot reassign members quot                        self   dict   name    value     cls   type  SpaceConstants                    setattr     setattr            return cls    sc   SpaceConstants    print sc x    raise  quot AttributeError   SpaceConstants  object has no attribute  x  quot  sc x   2   bind attribute x print sc x    print  quot 2 quot  sc x   3   raise  quot AttributeError  Cannot reassign members quot  sc y     name    y    value   2    bind attribute y print sc y    print  quot   name    y    value   2  quot  sc y  name      yprime    mutable object can be changed print sc y    print  quot   name    yprime    value   2  quot  sc y        raise  quot AttributeError  Cannot reassign members quot    A space of frozen values  SpaceFrozenValues  This next idiom is a modification of the SpaceConstants in where referenced mutable objects are frozen  This implementation exploits what I call shared closure between setattr and getattr functions  The value of the mutable object is copied and referenced by variable cache define inside of the function shared closure  It forms what I call a closure protected copy of a mutable object  You must be careful in using this idiom because getattr return the value of cache by doing a deep copy  This operation could have a significant performance impact on large objects  from copy import deepcopy  def SpaceFrozenValues        cache          def setattr self  name  value           nonlocal cache         if name in cache              raise AttributeError                   quot Cannot reassign members quot                        cache name    deepcopy value      def getattr self  name           nonlocal cache         if name not in cache              raise AttributeError                   quot Object has no attribute      quot  format name                        return deepcopy cache name       cls   type  SpaceFrozenValues                   getattr     getattr             setattr     setattr            return cls    fv   SpaceFrozenValues   print fv x    AttributeError  Object has no attribute  x  fv x   2   bind attribute x print fv x    print  quot 2 quot  fv x   3   raise  quot AttributeError  Cannot reassign members quot  fv y     name    y    value   2    bind attribute y print fv y    print  quot   name    y    value   2  quot  fv y  name      yprime    you can try to change mutable objects print fv y    print  quot   name    y    value   2  quot  fv y        raise  quot AttributeError  Cannot reassign members quot   A constant space  ConstantSpace  This idiom is an immutable namespace of constant variables or ConstantSpace  It is a combination of awesomely simple Jon Betts  answer in stackoverflow with a class factory  def ConstantSpace   args       args    slots              cls   type  ConstantSpace       args      return cls    cs   ConstantSpace      x   2      y     name    y    value   2     print cs x    print  quot 2 quot  cs x   3   raise  quot AttributeError   ConstantSpace  object attribute  x  is read-only quot  print cs y    print  quot   name    y    value   2  quot  cs y  name      yprime    mutable object can be changed print cs y    print  quot   name    yprime    value   2  quot  cs y        raise  quot AttributeError   ConstantSpace  object attribute  x  is read-only quot  cs z   3   raise  quot AttributeError   ConstantSpace  object has no attribute  z  quot   A frozen space  FrozenSpace  This idiom is an immutable namespace of frozen variables or FrozenSpace  It is derived from the previous pattern by making each variable a protected property by closure of the generated FrozenSpace class  from copy import deepcopy  def FreezeProperty value       cache   deepcopy value      return property          lambda self  deepcopy cache         def FrozenSpace   args       args    k  FreezeProperty v  for k  v in args items        args    slots              cls   type  FrozenSpace       args      return cls    fs   FrozenSpace      x   2      y     name    y    value   2     print fs x    print  quot 2 quot  fs x   3   raise  quot AttributeError   FrozenSpace  object attribute  x  is read-only quot  print fs y    print  quot   name    y    value   2  quot  fs y  name      yprime    try to change mutable object print fs y    print  quot   name    y    value   2  quot  fs y        raise  quot AttributeError   FrozenSpace  object attribute  x  is read-only quot  fs z   3   raise  quot AttributeError   FrozenSpace  object has no attribute  z  quot

User · Answer

Can t help but provide my own very light minimalist metaclass implementation  which may appear as a variation from the previous metaclass answer    Constants are stored inside a container class  no instantiation needed   Values can be set once  but cannot be changed  or deleted  once they are set   Personally I currently have no use-case for this  but was a fun exercise   class MetaConstant type           Metaclass that allows underlying class to store constants at class-level  subclass instance not needed           Non-existent attributes of underlying class  constants  can be set initially  but cannot be changed or deleted               def   setattr   klass  attr  value            If attribute  constant  doesn  t exist  set value  If attribute exists  raise AttributeError           if hasattr klass  attr               raise AttributeError f Can  t change the value of the constant  klass   name     attr  to  value                                    f   the value of  klass   name     attr  is already set to                                   f   getattr klass  attr               super     setattr   attr  value       def   delattr   klass  attr           if hasattr klass  attr               raise AttributeError f Can  t delete constant  klass   name     attr                                    f   set to  getattr klass  attr         class Constants metaclass MetaConstant        Container class for constants  No instantiation required        pass                 uncomment if no constants set upon class creation     B    Six              sets Constants B to  Six    Constants B   6           AttributeError del Constants B           AttributeError  Constants A    Five       sets Constants A to  Five  Constants A   5           AttributeError del Constants A           AttributeError    Feel free to suggest improvements

User · Answer

In python  a constant is simply a variable with a name in all capitals  with words separated by the underscore character   e g  DAYS IN WEEK   7  The value is mutable  as in you can change it   But given the rules for the name tell you is a constant  why would you   I mean  it is your program after all   This is the approach taken throughout python   There is no private keyword for the same reason   Prefix the name with an underscore and you know it is intended to be private   Code can break the rule    just as a programmer could remove the private keyword anyway    Python could have added a const keyword    but a programmer could remove keyword and then change the constant if they want to  but why do that   If you want to break the rule  you could change the rule anyway   But why bother to break the rule if the name makes the intention clear   Maybe there is some unit test where it makes sense to apply a change to value  To see what happens for an 8 day week even though in the real world the number of days in the week cannot be changed   If the language stopped you making an exception if there is just this one case you need to break the rule   you would then have to stop declaring it as a constant  even though it still is a constant in the application  and there is just this one test case that sees what happens if it is changed   The all upper case name tells you it is intended to be a constant  That is what is important  Not a language forcing constraints on code you have the power to change anyway   That is the philosophy of python

User · Answer

This paragraph was meant to be a comment on those answers here and there  which mentioned namedtuple  but it is getting too long to be fit into a comment  so  here it goes   The namedtuple approach mentioned above is definitely innovative  For the sake of completeness  though  at the end of the NamedTuple section of its official documentation  it reads   enumerated constants can be implemented with named tuples  but it is simpler and more efficient to use a simple class declaration  class Status      open  pending  closed   range 3    In other words  the official documentation kind of prefers to use a practical way  rather than actually implementing the read-only behavior  I guess it becomes yet another example of Zen of Python   Simple is better than complex  practicality beats purity

User · Answer

In addition to the two top answers  just use variables with UPPERCASE names  or use properties to make the values read-only   I want to mention that it s possible to use metaclasses in order to implement named constants   I provide a very simple solution using metaclasses at GitHub which may be helpful if you want the values to be more informative about their type name    gt  gt  gt  from named constants import Constants  gt  gt  gt  class Colors Constants           black   0         red   1         white   15      gt  gt  gt  c   Colors black  gt  gt  gt  c    0 True  gt  gt  gt  c Colors black  gt  gt  gt  c name    black   gt  gt  gt  Colors 0  is c True   This is slightly more advanced Python  but still very easy to use and handy    The module has some more features  including constants being read-only  see its README    There are similar solutions floating around in various repositories  but to the best of my knowledge they either lack one of the fundamental features that I would expect from constants  like being constant  or being of arbitrary type   or they have esoteric features added that make them less generally applicable   But YMMV  I would be grateful for feedback   -

User · Answer

Here s a trick if you want constants and don t care their values   Just define empty classes   e g   class RED       pass class BLUE       pass

User · Answer

I ve recently found a very succinct update to this which automatically raises meaningful error messages and prevents access via   dict     class CONST object         slots            FOO   1234  CONST   CONST      ----------  print CONST FOO       1234  CONST FOO   4321                AttributeError   CONST  object attribute  FOO  is read-only CONST   dict    FOO     4321    AttributeError   CONST  object has no attribute    dict    CONST BAR   5678                AttributeError   CONST  object has no attribute  BAR    We define over ourselves as to make ourselves an instance and then use slots to ensure that no additional attributes can be added  This also removes the   dict   access route  Of course  the whole object can still be redefined   Edit - Original solution  I m probably missing a trick here  but this seems to work for me   class CONST object       FOO   1234      def   setattr   self               pass  CONST   CONST     ----------  print CONST FOO      1234  CONST FOO   4321 CONST BAR   5678  print CONST FOO      Still 1234  print CONST BAR      Oops AttributeError   Creating the instance allows the magic   setattr   method to kick in and intercept attempts to set the FOO variable  You could throw an exception here if you wanted to  Instantiating the instance over the class name prevents access directly via the class   It s a total pain for one value  but you could attach lots to your CONST object  Having an upper class  class name also seems a bit grotty  but I think it s quite succinct overall

User · Answer

There is a cleaner way to do this with namedtuple   from collections import namedtuple   def make consts name    kwargs       return namedtuple name  kwargs keys      kwargs    Usage Example  CONSTS   make consts  baz1                        foo 1                       bar 2    With this exactly approach you can namespace your constants

User · Answer

In Python instead of language enforcing something  people use naming conventions e g   method for private methods and using  method for protected methods   So in same manner you can simply declare the constant as all caps e g   MY CONSTANT    one    If you want that this constant never changes  you can hook into attribute access and do tricks  but a simpler approach is to declare a function  def MY CONSTANT        return  one    Only problem is everywhere you will have to do MY CONSTANT    but again MY CONSTANT    one  is the correct way in python usually    You can also use namedtuple to create constants    gt  gt  gt  from collections import namedtuple  gt  gt  gt  Constants   namedtuple  Constants     pi    e     gt  gt  gt  constants   Constants 3 14  2 718   gt  gt  gt  constants pi 3 14  gt  gt  gt  constants pi   3 Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  AttributeError  can t set attribute

User · Answer

PEP 591 has the  final  qualifier  Enforcement is down to the type checker   So you can do    MY CONSTANT  Final   12407   Note  Final keyword is only applicable for Python 3 8 version

User · Answer

Properties are one way to create constants  You can do it by declaring a getter property  but ignoring the setter  For example   class MyFinalProperty object         property     def name self           return  John    You can have a look at an article I ve written to find more ways to use Python properties

User · Answer

I am trying different ways to create a real constant in Python and perhaps I found the pretty solution  Example  Create container for constants  gt  gt  gt  DAYS   Constants          MON 0          TUE 1          WED 2          THU 3          FRI 4          SAT 5          SUN 6           Get value from container  gt  gt  gt  DAYS MON 0  gt  gt  gt  DAYS  MON   0    Represent with pure python data structures  gt  gt  gt  list DAYS    WED    SUN    FRI    THU    MON    TUE    SAT    gt  gt  gt  dict DAYS    WED   2   SUN   6   FRI   4   THU   3   MON   0   TUE   1   SAT   5   All constants are immutable  gt  gt  gt  DAYS MON   7     AttributeError  Immutable attribute   gt  gt  gt  del DAYS MON      AttributeError  Immutable attribute  Autocomplete only for constants  gt  gt  gt  dir DAYS    FRI    MON    SAT    SUN    THU    TUE    WED    Sorting like list sort  gt  gt  gt  DAYS sort key lambda  k  v   v  reverse True   gt  gt  gt  list DAYS    SUN    SAT    FRI    THU    WED    TUE    MON    Copability with python2 and python3 Simple container for constants from collections import OrderedDict from copy import deepcopy  class Constants object        quot  quot  quot Container of constant quot  quot  quot         slots         dict          def   init   self    kwargs            if list filter lambda x  not x isupper    kwargs                raise AttributeError  Constant name should be uppercase             super Constants  self    setattr                   dict                 OrderedDict map lambda x   x 0   deepcopy x 1     kwargs items                    def sort self  key None  reverse False           super Constants  self    setattr                   dict                 OrderedDict sorted self   dict   items    key key  reverse reverse                  def   getitem   self  name           return self   dict   name       def   len   self           return  len self   dict         def   iter   self           for name in self   dict                yield name      def keys self           return list self       def   str   self           return str list self        def   repr   self           return   lt  s   s gt      self   class     name    str self   dict          def   dir   self           return list self       def   setattr   self  name  value           raise AttributeError  quot Immutable attribute quot        def   delattr                raise AttributeError  quot Immutable attribute quot

User · Answer

Unfortunately the Python has no constants so yet and it is shame  ES6 already added support constants to JavaScript  https   developer mozilla org en docs Web JavaScript Reference Statements const  since it is a very useful thing in any programming language  As answered in other answers in Python community use the convention - user uppercase variable as constants  but it does not protect against arbitrary errors in code  If you like  you may be found useful a single-file solution as next  see docstrings how use it    file constants py  import collections     all       const       class Constant object               Implementation strict constants in Python 3       A constant can be set up  but can not be changed or deleted      Value of constant may any immutable type  as well as list or set      Besides if value of a constant is list or set  it will be converted in an immutable type as next          list - gt  tuple         set - gt  frozenset     Dict as value of a constant has no support        gt  gt  gt  const   Constant        gt  gt  gt  del const temp     Traceback  most recent call last       NameError  name  temp  is not defined      gt  gt  gt  const temp   1      gt  gt  gt  const temp   88     Traceback  most recent call last                   TypeError  Constanst can not be changed      gt  gt  gt  del const temp     Traceback  most recent call last                   TypeError  Constanst can not be deleted      gt  gt  gt  const I     a   1  1 2       gt  gt  gt  print const I        a   1  1 2       gt  gt  gt  const F    1 2       gt  gt  gt  print const F      frozenset  1 2        gt  gt  gt  const D   dict       Traceback  most recent call last                   TypeError  dict can not be used as constant      gt  gt  gt  del const UNDEFINED     Traceback  most recent call last                   NameError  name  UNDEFINED  is not defined      gt  gt  gt  const         I     a   1  1 2    temp   1   F   frozenset  1 2                 def   setattr   self  name  value              Declaration a constant with value  If mutable - it will be converted to immutable  if possible          If the constant already exists  then made prevent againt change it              if name in self   dict                raise TypeError  Constanst can not be changed            if not isinstance value  collections Hashable               if isinstance value  list                   value   tuple value              elif isinstance value  set                   value   frozenset value              elif isinstance value  dict                   raise TypeError  dict can not be used as constant               else                  raise ValueError  Muttable or custom type is not supported           self   dict   name    value      def   delattr   self  name              Deny against deleting a declared constant              if name in self   dict                raise TypeError  Constanst can not be deleted           raise NameError  name   s  is not defined    name       def   call   self              Return all constans              return self   dict     const   Constant     if   name         main         import doctest     doctest testmod     If this is not enough  see full testcase for it   import decimal import uuid import datetime import unittest  from   constants import Constant   class TestConstant unittest TestCase               Test for implementation constants in the Python              def setUp self            self const   Constant        def tearDown self            del self const      def test create constant with different variants of name self            self const CONSTANT   1         self assertEqual self const CONSTANT  1          self const Constant   2         self assertEqual self const Constant  2          self const ConStAnT   3         self assertEqual self const ConStAnT  3          self const constant   4         self assertEqual self const constant  4          self const co ns ta nt   5         self assertEqual self const co ns ta nt  5          self const constant1111   6         self assertEqual self const constant1111  6       def test create and change integer constant self            self const INT   1234         self assertEqual self const INT  1234          with self assertRaisesRegexp TypeError   Constanst can not be changed                self const INT    211      def test create and change float constant self            self const FLOAT    1234         self assertEqual self const FLOAT   1234          with self assertRaisesRegexp TypeError   Constanst can not be changed                self const FLOAT    211      def test create and change list constant but saved as tuple self            self const LIST    1   2  None  True  datetime date today                    self assertEqual self const LIST   1   2  None  True  datetime date today                      self assertTrue isinstance self const LIST  tuple            with self assertRaisesRegexp TypeError   Constanst can not be changed                self const LIST    211      def test create and change none constant self            self const NONE   None         self assertEqual self const NONE  None          with self assertRaisesRegexp TypeError   Constanst can not be changed                self const NONE    211      def test create and change boolean constant self            self const BOOLEAN   True         self assertEqual self const BOOLEAN  True          with self assertRaisesRegexp TypeError   Constanst can not be changed                self const BOOLEAN   False      def test create and change string constant self            self const STRING    Text          self assertEqual self const STRING   Text            with self assertRaisesRegexp TypeError   Constanst can not be changed                self const STRING                   with self assertRaisesRegexp TypeError   Constanst can not be changed                self const STRING    TEst1       def test create dict constant self            with self assertRaisesRegexp TypeError   dict can not be used as constant                self const DICT           def test create and change tuple constant self            self const TUPLE    1   2  None  True  datetime date today                    self assertEqual self const TUPLE   1   2  None  True  datetime date today                      with self assertRaisesRegexp TypeError   Constanst can not be changed                self const TUPLE    TEst1       def test create and change set constant self            self const SET    1   2  None  True  datetime date today            self assertEqual self const SET   1   2  None  True  datetime date today              self assertTrue isinstance self const SET  frozenset            with self assertRaisesRegexp TypeError   Constanst can not be changed                self const SET   3212      def test create and change frozenset constant self            self const FROZENSET   frozenset  1   2  None  True  datetime date today             self assertEqual self const FROZENSET  frozenset  1   2  None  True  datetime date today               with self assertRaisesRegexp TypeError   Constanst can not be changed                self const FROZENSET   True      def test create and change date constant self            self const DATE   datetime date 1111  11  11          self assertEqual self const DATE  datetime date 1111  11  11            with self assertRaisesRegexp TypeError   Constanst can not be changed                self const DATE   True      def test create and change datetime constant self            self const DATETIME   datetime datetime 2000  10  10  10  10          self assertEqual self const DATETIME  datetime datetime 2000  10  10  10  10            with self assertRaisesRegexp TypeError   Constanst can not be changed                self const DATETIME   None      def test create and change decimal constant self            self const DECIMAL   decimal Decimal 13123 12312312321          self assertEqual self const DECIMAL  decimal Decimal 13123 12312312321            with self assertRaisesRegexp TypeError   Constanst can not be changed                self const DECIMAL   None      def test create and change timedelta constant self            self const TIMEDELTA   datetime timedelta days 45          self assertEqual self const TIMEDELTA  datetime timedelta days 45            with self assertRaisesRegexp TypeError   Constanst can not be changed                self const TIMEDELTA   1      def test create and change uuid constant self            value   uuid uuid4           self const UUID   value         self assertEqual self const UUID  value           with self assertRaisesRegexp TypeError   Constanst can not be changed                self const UUID           def test try delete defined const self            self const VERSION    0 0 1          with self assertRaisesRegexp TypeError   Constanst can not be deleted                del self const VERSION      def test try delete undefined const self            with self assertRaisesRegexp NameError   name  UNDEFINED  is not defined                del self const UNDEFINED      def test get all defined constants self            self assertDictEqual self const                 self const A   1         self assertDictEqual self const      A   1            self const B    Text          self assertDictEqual self const      A   1   B    Text      Advantages   1  Access to all constants for whole project  2  Strict control for values of constants  Lacks   1  Not support for custom types and the type  dict   Notes    Tested with Python3 4 and Python3 5  I am use the  tox  for it  Testing environment         uname -a Linux wlysenko-Aspire 3 13 0-37-generic  64-Ubuntu SMP Mon Sep 22 21 28 38 UTC 2014 x86 64 x86 64 x86 64 GNU Linux

[python] How do I create a constant in Python?

Examples related to python

Examples related to constants