What is the Python equivalent of static variables inside a function

Question

What is the idiomatic Python equivalent of this C C   code   void foo         static int counter   0      counter        printf  counter is  d n   counter       specifically  how does one implement the static member at the function level  as opposed to the class level  And does placing the function into a class change anything

User · Answer

One could also consider   def foo        try          foo counter    1     except AttributeError          foo counter   1   Reasoning    much pythonic   ask for forgiveness not permission   use exception  thrown only once  instead of if branch  think StopIteration exception

User · Answer

Instead of creating a function having a static local variable  you can always create what is called a  function object  and give it a standard  non-static  member variable   Since you gave an example written C    I will first explain what a  function object  is in C    A  function object  is simply any class with an overloaded operator    Instances of the class will behave like functions  For example  you can write int x   square 5   even if square is an object  with overloaded operator    and not technically not a  function   You can give a function-object any of the features that you could give a class object     C   function object class Foo class       private          int counter           public          Foo class                  counter   0                    void operator                      counter                printf  counter is  d n   counter                           Foo class foo    In Python  we can also overload operator   except that the method is instead named   call     Here is a class definition   class Foo class      def   init   self       init   is similair to a C   class constructor         self counter   0           self counter is like a static member           variable of a function named  foo      def   call   self     overload operator           self counter    1         print  counter is  d    self counter   foo   Foo class     call the constructor   Here is an example of the class being used   from foo import foo  for i in range 0  5       foo     function call   The output printed to the console is   counter is 1 counter is 2 counter is 3 counter is 4 counter is 5   If you want your function to take input arguments  you can add those to   call   as well     FILE  foo py - - - - - - - - - - - - - - - - - - - - - - - - -  class Foo class      def   init   self           self counter   0     def   call   self  x  y  z     overload operator           self counter    1         print  counter is  d    self counter           print  x  y  z  are  d   d   d     x  y  z    foo   Foo class     call the constructor    FILE  main py - - - - - - - - - - - - - - - - - - - - - - - - - - - -   from foo import foo  for i in range 0  5       foo 7  8  9    function call    Console Output - - - - - - - - - - - - - - - - - - - - - - - - - -   counter is 1 x  y  z  are 7  8  9 counter is 2 x  y  z  are 7  8  9 counter is 3 x  y  z  are 7  8  9 counter is 4 x  y  z  are 7  8  9 counter is 5 x  y  z  are 7  8  9

User · Answer

I write a simple function to use static variables  def Static            get the func object by which Static   is called      from inspect import currentframe  getframeinfo     caller   currentframe   f back     func name   getframeinfo caller  2        print func name      caller   caller f back     func   caller f locals get          func name  caller f globals get              func name                          class StaticVars          def has self  varName               return hasattr self  varName          def declare self  varName  value               if not self has varName                   setattr self  varName  value       if hasattr func   quot staticVars quot            return func staticVars     else            add an attribute to func         func staticVars   StaticVars           return func staticVars  How to use  def myfunc arg       if Static   has  test1            Static   test    1     else          Static   test   1     print Static   test         declare   only takes effect in the first time for each static variable      Static   declare  test2   1      print Static   test2      Static   test2    1

User · Answer

Here is a fully encapsulated version that doesn t require an external initialization call   def fn        fn counter vars fn  setdefault  counter  -1      fn counter  1     print  fn counter    In Python  functions are objects and we can simply add  or monkey patch  member variables to them via the special attribute   dict    The built-in vars   returns the special attribute   dict        EDIT  Note  unlike the alternative try except AttributeError answer  with this approach the variable will always be ready for the code logic following initialization  I think the try except AttributeError alternative to the following will be less DRY and or have awkward flow      def Fibonacci n      if n lt 2  return n    Fibonacci memo vars Fibonacci  setdefault  memo        use static variable to hold a results cache    return Fibonacci memo setdefault n Fibonacci n-1  Fibonacci n-2     lookup result in cache  if not available then calculate and store it   EDIT2  I only recommend the above approach when the function will be called from multiple locations  If instead the function is only called in one place  it s better to use nonlocal   def TheOnlyPlaceStaticFunctionIsCalled        memo        def Fibonacci n          nonlocal memo    required in Python3  Python2 can see memo        if n lt 2  return n        return memo setdefault n Fibonacci n-1  Fibonacci n-2               print  Fibonacci 200

User · Answer

Use a generator function to generate an iterator   def foo gen        n   0     while True          n  1         yield n   Then use it like  foo   foo gen   next for i in range 0 10       print foo     If you want an upper limit   def foo gen limit 100000       n   0     while n  lt  limit         n  1        yield n   If the iterator terminates  like the example above   you can also loop over it directly  like  for i in foo gen 20       print i   Of course  in these simple cases it s better to use xrange     Here is the documentation on the yield statement

User · Answer

A global declaration provides this functionality  In the example below  python 3 5 or greater to use the  f    the counter variable is defined outside of the function  Defining it as global in the function signifies that the  global  version outside of the function should be made available to the function  So each time the function runs  it modifies the value outside the function  preserving it beyond the function   counter   0  def foo        global counter     counter    1     print  counter is     format counter    foo    output   counter is 1  foo    output   counter is 2  foo    output   counter is 3

User · Answer

You can add attributes to a function  and use it as a static variable   def myfunc      myfunc counter    1   print myfunc counter    attribute must be initialized myfunc counter   0   Alternatively  if you don t want to setup the variable outside the function  you can use hasattr   to avoid an AttributeError exception   def myfunc      if not hasattr myfunc   counter         myfunc counter   0    it doesn t exist yet  so initialize it   myfunc counter    1   Anyway static variables are rather rare  and you should find a better place for this variable  most likely inside a class

User · Answer

Use a generator function to generate an iterator   def foo gen        n   0     while True          n  1         yield n   Then use it like  foo   foo gen   next for i in range 0 10       print foo     If you want an upper limit   def foo gen limit 100000       n   0     while n  lt  limit         n  1        yield n   If the iterator terminates  like the example above   you can also loop over it directly  like  for i in foo gen 20       print i   Of course  in these simple cases it s better to use xrange     Here is the documentation on the yield statement

User · Answer

Soulution n   1   def foo      foo   dict   setdefault  count   0    foo count    1   return foo count

User · Answer

Other solutions attach a counter attribute to the function  usually with convoluted logic to handle the initialization  This is inappropriate for new code   In Python 3  the right way is to use a nonlocal statement   counter   0 def foo        nonlocal counter     counter    1     print f counter is  counter      See PEP 3104 for the specification of the nonlocal statement   If the counter is intended to be private to the module  it should be named  counter instead

User · Answer

counter   0 def foo       global  counter     counter    1    print  counter is    counter   Python customarily uses underscores to indicate private variables  The only reason in C to declare the static variable inside the function is to hide it outside the function  which is not really idiomatic Python

User · Answer

Prompted by this question  may I present another alternative which might be a bit nicer to use and will look the same for both methods and functions    static var2  seed  0  def funccounter statics  add 1       statics seed    add     return statics seed  print funccounter          1 print funccounter add 2    3 print funccounter          4  class ACircle object        static var2  seed  0      def counter statics  self  add 1           statics seed    add         return statics seed  c   ACircle   print c counter         1 print c counter add 2   3 print c counter         4 d   ACircle   print d counter         5 print d counter add 2   7 print d counter         8          If you like the usage  here s the implementation   class StaticMan object       def   init   self           self   dict     d             def   getattr   self  name           return self   dict     d   name      def   getitem   self  name           return self   dict     d   name      def   setattr   self  name  val           self   dict     d   name    val     def   setitem   self  name  val           self   dict     d   name    val  def static var2 name  val       def decorator original           if not hasattr original    staticman                    def wrapped  args    kwargs                   return original getattr wrapped    staticman     args    kwargs              setattr wrapped    staticman   StaticMan                f   wrapped         else              f   original  already wrapped          getattr f    staticman   name    val         return f     return decorator

User · Answer

counter   0 def foo       global  counter     counter    1    print  counter is    counter   Python customarily uses underscores to indicate private variables  The only reason in C to declare the static variable inside the function is to hide it outside the function  which is not really idiomatic Python

User · Answer

Other answers have demonstrated the way you should do this  Here s a way you shouldn t    gt  gt  gt  def foo counter  0          counter 0     1       print  Counter is  i     counter 0          gt  gt  gt  foo   Counter is 1   gt  gt  gt  foo   Counter is 2   gt  gt  gt     Default values are initialized only when the function is first evaluated  not each time it is executed  so you can use a list or any other mutable object to store static values

User · Answer

Other answers have demonstrated the way you should do this  Here s a way you shouldn t    gt  gt  gt  def foo counter  0          counter 0     1       print  Counter is  i     counter 0          gt  gt  gt  foo   Counter is 1   gt  gt  gt  foo   Counter is 2   gt  gt  gt     Default values are initialized only when the function is first evaluated  not each time it is executed  so you can use a list or any other mutable object to store static values

User · Answer

A bit reversed  but this should work   def foo        foo counter    1     print  Counter is  d    foo counter foo counter   0   If you want the counter initialization code at the top instead of the bottom  you can create a decorator   def static vars   kwargs       def decorate func           for k in kwargs              setattr func  k  kwargs k           return func     return decorate   Then use the code like this    static vars counter 0  def foo        foo counter    1     print  Counter is  d    foo counter   It ll still require you to use the foo  prefix  unfortunately    Credit   ony

User · Answer

You can add attributes to a function  and use it as a static variable   def myfunc      myfunc counter    1   print myfunc counter    attribute must be initialized myfunc counter   0   Alternatively  if you don t want to setup the variable outside the function  you can use hasattr   to avoid an AttributeError exception   def myfunc      if not hasattr myfunc   counter         myfunc counter   0    it doesn t exist yet  so initialize it   myfunc counter    1   Anyway static variables are rather rare  and you should find a better place for this variable  most likely inside a class

User · Answer

Sure this is an old question but I think I might provide some update   It seems that the performance argument is obsolete   The same test suite appears to give similar results for siInt try and isInt re2  Of course results vary  but this is one session on my computer with python 3 4 4 on kernel 4 3 01 with Xeon W3550  I have run it several times and the results seem to be similar  I moved the global regex into function static  but the performance difference is negligible    isInt try  0 3690 isInt str  0 3981 isInt re  0 5870 isInt re2  0 3632   With performance issue out of the way  it seems that try catch would produce the most future- and cornercase- proof code so maybe just wrap it in function

User · Answer

Building on Daniel s answer  additions    class Foo object        counter   0    def   call   self  inc value 0       Foo counter    inc value     return Foo counter  foo   Foo    def use foo x y       if x  5           foo 2      elif y  7           foo 3      if foo      10           print  yello     use foo 5 1  use foo 5 1  use foo 1 7  use foo 1 7  use foo 1 1    The reason why I wanted to add this part is   static variables are used not only for incrementing by some value  but also check if the static var is equal to some value  as a real life example   The static variable is still protected and used only within the scope of the function use foo    In this example  call to foo   functions exactly as with respect to the corresponding c   equivalent     stat c   9     in c   foo 9    python equiv  if stat c  10     do something      c    if foo      10          python equiv    add code here        python equiv         Output   yello yello   if class Foo is defined restrictively as a singleton class  that would be ideal  This would make it more pythonic

User · Answer

A little bit more readable  but more verbose  Zen of Python  explicit is better than implicit     gt  gt  gt  def func  static   counter   0             static  counter      1         print  static  counter        gt  gt  gt  func   1  gt  gt  gt  func   2  gt  gt  gt    See here for an explanation of how this works

User · Answer

I personally prefer the following to decorators  To each their own   def staticize name  factory          Makes a pseudo-static variable in calling function       If name  name  exists in calling function  return it       Otherwise  saves return value of  factory    in      name  name  of calling function and return it        param name  name to use to store static object      in calling function      type name  String      param factory  used to initialize name  name       in calling function      type factory  function      rtype   type factory           gt  gt  gt  def steveholt z               a   staticize  a   list              a append z       gt  gt  gt  steveholt a     Traceback  most recent call last               AttributeError   function  object has no attribute  a       gt  gt  gt  steveholt 1       gt  gt  gt  steveholt a      1       gt  gt  gt  steveholt  a        gt  gt  gt  steveholt a      1   a        gt  gt  gt  steveholt a           gt  gt  gt  steveholt a             gt  gt  gt  steveholt  zzz        gt  gt  gt  steveholt a       zzz                from inspect import stack       get scope enclosing calling function     calling fn scope   stack   2  0        get calling function     calling fn name   stack   1  3      calling fn   calling fn scope f locals calling fn name      if not hasattr calling fn  name           setattr calling fn  name  factory        return getattr calling fn  name

User · Answer

Many people have already suggested testing  hasattr   but there s a simpler answer   def func        func counter   getattr func   counter   0    1   No try except  no testing hasattr  just getattr with a default

User · Answer

Use a generator function to generate an iterator   def foo gen        n   0     while True          n  1         yield n   Then use it like  foo   foo gen   next for i in range 0 10       print foo     If you want an upper limit   def foo gen limit 100000       n   0     while n  lt  limit         n  1        yield n   If the iterator terminates  like the example above   you can also loop over it directly  like  for i in foo gen 20       print i   Of course  in these simple cases it s better to use xrange     Here is the documentation on the yield statement

User · Answer

A little bit more readable  but more verbose  Zen of Python  explicit is better than implicit     gt  gt  gt  def func  static   counter   0             static  counter      1         print  static  counter        gt  gt  gt  func   1  gt  gt  gt  func   2  gt  gt  gt    See here for an explanation of how this works

User · Answer

def staticvariables   variables       def decorate function           for variable in variables              setattr function  variable  variables variable           return function     return decorate   staticvariables counter 0  bar 1  def foo        print foo counter      print foo bar    Much like vincent s code above  this would be used as a function decorator and static variables must be accessed with the function name as a prefix  The advantage of this code  although admittedly anyone might be smart enough to figure it out  is that you can have multiple static variables and initialise them in a more conventional manner

User · Answer

Python doesn t have static variables but you can fake it by defining a callable class object and then using it as a function  Also see this answer   class Foo object       Class variable  shared by all instances of this class   counter   0    def   call   self       Foo counter    1     print Foo counter    Create an object instance of class  Foo   called  foo  foo   Foo      Make calls to the    call    method  via the object s name itself foo    prints 1 foo    prints 2 foo    prints 3   Note that   call   makes an instance of a class  object  callable by its own name  That s why calling foo   above calls the class    call   method  From the documentation      Instances of arbitrary classes can be made callable by defining a   call     method in their class

User · Answer

I personally prefer the following to decorators  To each their own   def staticize name  factory          Makes a pseudo-static variable in calling function       If name  name  exists in calling function  return it       Otherwise  saves return value of  factory    in      name  name  of calling function and return it        param name  name to use to store static object      in calling function      type name  String      param factory  used to initialize name  name       in calling function      type factory  function      rtype   type factory           gt  gt  gt  def steveholt z               a   staticize  a   list              a append z       gt  gt  gt  steveholt a     Traceback  most recent call last               AttributeError   function  object has no attribute  a       gt  gt  gt  steveholt 1       gt  gt  gt  steveholt a      1       gt  gt  gt  steveholt  a        gt  gt  gt  steveholt a      1   a        gt  gt  gt  steveholt a           gt  gt  gt  steveholt a             gt  gt  gt  steveholt  zzz        gt  gt  gt  steveholt a       zzz                from inspect import stack       get scope enclosing calling function     calling fn scope   stack   2  0        get calling function     calling fn name   stack   1  3      calling fn   calling fn scope f locals calling fn name      if not hasattr calling fn  name           setattr calling fn  name  factory        return getattr calling fn  name

User · Answer

Python doesn t have static variables but you can fake it by defining a callable class object and then using it as a function  Also see this answer   class Foo object       Class variable  shared by all instances of this class   counter   0    def   call   self       Foo counter    1     print Foo counter    Create an object instance of class  Foo   called  foo  foo   Foo      Make calls to the    call    method  via the object s name itself foo    prints 1 foo    prints 2 foo    prints 3   Note that   call   makes an instance of a class  object  callable by its own name  That s why calling foo   above calls the class    call   method  From the documentation      Instances of arbitrary classes can be made callable by defining a   call     method in their class

User · Answer

Other answers have demonstrated the way you should do this  Here s a way you shouldn t    gt  gt  gt  def foo counter  0          counter 0     1       print  Counter is  i     counter 0          gt  gt  gt  foo   Counter is 1   gt  gt  gt  foo   Counter is 2   gt  gt  gt     Default values are initialized only when the function is first evaluated  not each time it is executed  so you can use a list or any other mutable object to store static values

User · Answer

A bit reversed  but this should work   def foo        foo counter    1     print  Counter is  d    foo counter foo counter   0   If you want the counter initialization code at the top instead of the bottom  you can create a decorator   def static vars   kwargs       def decorate func           for k in kwargs              setattr func  k  kwargs k           return func     return decorate   Then use the code like this    static vars counter 0  def foo        foo counter    1     print  Counter is  d    foo counter   It ll still require you to use the foo  prefix  unfortunately    Credit   ony

User · Answer

Python doesn t have static variables but you can fake it by defining a callable class object and then using it as a function  Also see this answer   class Foo object       Class variable  shared by all instances of this class   counter   0    def   call   self       Foo counter    1     print Foo counter    Create an object instance of class  Foo   called  foo  foo   Foo      Make calls to the    call    method  via the object s name itself foo    prints 1 foo    prints 2 foo    prints 3   Note that   call   makes an instance of a class  object  callable by its own name  That s why calling foo   above calls the class    call   method  From the documentation      Instances of arbitrary classes can be made callable by defining a   call     method in their class

User · Answer

Another  not recommended   twist on the callable object like https   stackoverflow com a 279598 916373  if you don t mind using a funky call signature  would be to do  class foo object       counter   0       staticmethod     def   call              foo counter    1         print  counter is  i    foo counter      gt  gt  gt  foo     counter is 1  gt  gt  gt  foo     counter is 2

User · Answer

Another  not recommended   twist on the callable object like https   stackoverflow com a 279598 916373  if you don t mind using a funky call signature  would be to do  class foo object       counter   0       staticmethod     def   call              foo counter    1         print  counter is  i    foo counter      gt  gt  gt  foo     counter is 1  gt  gt  gt  foo     counter is 2

User · Answer

The idiomatic way is to use a class  which can have attributes   If you need instances to not be separate  use a singleton   There are a number of ways you could fake or munge  static  variables into Python  one not mentioned so far is to have a mutable default argument   but this is not the Pythonic  idiomatic way to do it   Just use a class   Or possibly a generator  if your usage pattern fits

User · Answer

A static variable inside a Python method  class Count      def foo self           try               self foo   func   counter    1         except AttributeError               self foo   func   counter   1          print self foo   func   counter  m   Count   m foo           1 m foo           2 m foo           3

User · Answer

This answer builds on  claudiu  s  answer   I found that my code was getting less clear when I always had  to prepend the function name  whenever I intend to access a static variable   Namely  in my function code I would prefer to write   print statics foo    instead of  print my function name foo    So  my solution is to     add a statics attribute to the  function in the function scope  add a local variable statics as an alias to my function statics   from bunch import    def static vars   kwargs       def decorate func           statics   Bunch   kwargs          setattr func   statics   statics          return func     return decorate   static vars name    Martin   def my function        statics   my function statics     print  Hello   0   format statics name       Remark  My method uses a class named Bunch  which is a dictionary that supports  attribute-style access  a la JavaScript  see the original article about it  around 2000   It can be installed via pip install bunch  It can also be hand-written like so   class Bunch dict       def   init   self    kw           dict   init   self kw          self   dict     self

User · Answer

After trying several approaches I end up using an improved version of  warvariuc s answer   import types  def func  static types SimpleNamespace counter 0         static counter    1     print  static counter

User · Answer

After trying several approaches I end up using an improved version of  warvariuc s answer   import types  def func  static types SimpleNamespace counter 0         static counter    1     print  static counter

User · Answer

A static variable inside a Python method  class Count      def foo self           try               self foo   func   counter    1         except AttributeError               self foo   func   counter   1          print self foo   func   counter  m   Count   m foo           1 m foo           2 m foo           3

User · Answer

Using an attribute of a function as static variable has some potential drawbacks    Every time you want to access the variable  you have to write out the full name of the function   Outside code can access the variable easily and mess with the value    Idiomatic python for the second issue would probably be naming the variable with a leading underscore to signal that it is not meant to be accessed  while keeping it accessible after the fact    An alternative would be a pattern using lexical closures  which are supported with the nonlocal keyword in python 3   def make counter        i   0     def counter            nonlocal i         i   i   1         return i     return counter counter   make counter     Sadly I know no way to encapsulate this solution into a decorator

User · Answer

You can add attributes to a function  and use it as a static variable   def myfunc      myfunc counter    1   print myfunc counter    attribute must be initialized myfunc counter   0   Alternatively  if you don t want to setup the variable outside the function  you can use hasattr   to avoid an AttributeError exception   def myfunc      if not hasattr myfunc   counter         myfunc counter   0    it doesn t exist yet  so initialize it   myfunc counter    1   Anyway static variables are rather rare  and you should find a better place for this variable  most likely inside a class

User · Answer

def staticvariables   variables       def decorate function           for variable in variables              setattr function  variable  variables variable           return function     return decorate   staticvariables counter 0  bar 1  def foo        print foo counter      print foo bar    Much like vincent s code above  this would be used as a function decorator and static variables must be accessed with the function name as a prefix  The advantage of this code  although admittedly anyone might be smart enough to figure it out  is that you can have multiple static variables and initialise them in a more conventional manner

User · Answer

Building on Daniel s answer  additions    class Foo object        counter   0    def   call   self  inc value 0       Foo counter    inc value     return Foo counter  foo   Foo    def use foo x y       if x  5           foo 2      elif y  7           foo 3      if foo      10           print  yello     use foo 5 1  use foo 5 1  use foo 1 7  use foo 1 7  use foo 1 1    The reason why I wanted to add this part is   static variables are used not only for incrementing by some value  but also check if the static var is equal to some value  as a real life example   The static variable is still protected and used only within the scope of the function use foo    In this example  call to foo   functions exactly as with respect to the corresponding c   equivalent     stat c   9     in c   foo 9    python equiv  if stat c  10     do something      c    if foo      10          python equiv    add code here        python equiv         Output   yello yello   if class Foo is defined restrictively as a singleton class  that would be ideal  This would make it more pythonic

User · Answer

Prompted by this question  may I present another alternative which might be a bit nicer to use and will look the same for both methods and functions    static var2  seed  0  def funccounter statics  add 1       statics seed    add     return statics seed  print funccounter          1 print funccounter add 2    3 print funccounter          4  class ACircle object        static var2  seed  0      def counter statics  self  add 1           statics seed    add         return statics seed  c   ACircle   print c counter         1 print c counter add 2   3 print c counter         4 d   ACircle   print d counter         5 print d counter add 2   7 print d counter         8          If you like the usage  here s the implementation   class StaticMan object       def   init   self           self   dict     d             def   getattr   self  name           return self   dict     d   name      def   getitem   self  name           return self   dict     d   name      def   setattr   self  name  val           self   dict     d   name    val     def   setitem   self  name  val           self   dict     d   name    val  def static var2 name  val       def decorator original           if not hasattr original    staticman                    def wrapped  args    kwargs                   return original getattr wrapped    staticman     args    kwargs              setattr wrapped    staticman   StaticMan                f   wrapped         else              f   original  already wrapped          getattr f    staticman   name    val         return f     return decorator

User · Answer

One could also consider   def foo        try          foo counter    1     except AttributeError          foo counter   1   Reasoning    much pythonic   ask for forgiveness not permission   use exception  thrown only once  instead of if branch  think StopIteration exception

User · Answer

Other answers have demonstrated the way you should do this  Here s a way you shouldn t    gt  gt  gt  def foo counter  0          counter 0     1       print  Counter is  i     counter 0          gt  gt  gt  foo   Counter is 1   gt  gt  gt  foo   Counter is 2   gt  gt  gt     Default values are initialized only when the function is first evaluated  not each time it is executed  so you can use a list or any other mutable object to store static values

User · Answer

Using an attribute of a function as static variable has some potential drawbacks    Every time you want to access the variable  you have to write out the full name of the function   Outside code can access the variable easily and mess with the value    Idiomatic python for the second issue would probably be naming the variable with a leading underscore to signal that it is not meant to be accessed  while keeping it accessible after the fact    An alternative would be a pattern using lexical closures  which are supported with the nonlocal keyword in python 3   def make counter        i   0     def counter            nonlocal i         i   i   1         return i     return counter counter   make counter     Sadly I know no way to encapsulate this solution into a decorator

User · Answer

Sure this is an old question but I think I might provide some update   It seems that the performance argument is obsolete   The same test suite appears to give similar results for siInt try and isInt re2  Of course results vary  but this is one session on my computer with python 3 4 4 on kernel 4 3 01 with Xeon W3550  I have run it several times and the results seem to be similar  I moved the global regex into function static  but the performance difference is negligible    isInt try  0 3690 isInt str  0 3981 isInt re  0 5870 isInt re2  0 3632   With performance issue out of the way  it seems that try catch would produce the most future- and cornercase- proof code so maybe just wrap it in function

User · Answer

Here is a fully encapsulated version that doesn t require an external initialization call   def fn        fn counter vars fn  setdefault  counter  -1      fn counter  1     print  fn counter    In Python  functions are objects and we can simply add  or monkey patch  member variables to them via the special attribute   dict    The built-in vars   returns the special attribute   dict        EDIT  Note  unlike the alternative try except AttributeError answer  with this approach the variable will always be ready for the code logic following initialization  I think the try except AttributeError alternative to the following will be less DRY and or have awkward flow      def Fibonacci n      if n lt 2  return n    Fibonacci memo vars Fibonacci  setdefault  memo        use static variable to hold a results cache    return Fibonacci memo setdefault n Fibonacci n-1  Fibonacci n-2     lookup result in cache  if not available then calculate and store it   EDIT2  I only recommend the above approach when the function will be called from multiple locations  If instead the function is only called in one place  it s better to use nonlocal   def TheOnlyPlaceStaticFunctionIsCalled        memo        def Fibonacci n          nonlocal memo    required in Python3  Python2 can see memo        if n lt 2  return n        return memo setdefault n Fibonacci n-1  Fibonacci n-2               print  Fibonacci 200

User · Answer

Soulution n   1   def foo      foo   dict   setdefault  count   0    foo count    1   return foo count

User · Answer

You can add attributes to a function  and use it as a static variable   def myfunc      myfunc counter    1   print myfunc counter    attribute must be initialized myfunc counter   0   Alternatively  if you don t want to setup the variable outside the function  you can use hasattr   to avoid an AttributeError exception   def myfunc      if not hasattr myfunc   counter         myfunc counter   0    it doesn t exist yet  so initialize it   myfunc counter    1   Anyway static variables are rather rare  and you should find a better place for this variable  most likely inside a class

User · Answer

Instead of creating a function having a static local variable  you can always create what is called a  function object  and give it a standard  non-static  member variable   Since you gave an example written C    I will first explain what a  function object  is in C    A  function object  is simply any class with an overloaded operator    Instances of the class will behave like functions  For example  you can write int x   square 5   even if square is an object  with overloaded operator    and not technically not a  function   You can give a function-object any of the features that you could give a class object     C   function object class Foo class       private          int counter           public          Foo class                  counter   0                    void operator                      counter                printf  counter is  d n   counter                           Foo class foo    In Python  we can also overload operator   except that the method is instead named   call     Here is a class definition   class Foo class      def   init   self       init   is similair to a C   class constructor         self counter   0           self counter is like a static member           variable of a function named  foo      def   call   self     overload operator           self counter    1         print  counter is  d    self counter   foo   Foo class     call the constructor   Here is an example of the class being used   from foo import foo  for i in range 0  5       foo     function call   The output printed to the console is   counter is 1 counter is 2 counter is 3 counter is 4 counter is 5   If you want your function to take input arguments  you can add those to   call   as well     FILE  foo py - - - - - - - - - - - - - - - - - - - - - - - - -  class Foo class      def   init   self           self counter   0     def   call   self  x  y  z     overload operator           self counter    1         print  counter is  d    self counter           print  x  y  z  are  d   d   d     x  y  z    foo   Foo class     call the constructor    FILE  main py - - - - - - - - - - - - - - - - - - - - - - - - - - - -   from foo import foo  for i in range 0  5       foo 7  8  9    function call    Console Output - - - - - - - - - - - - - - - - - - - - - - - - - -   counter is 1 x  y  z  are 7  8  9 counter is 2 x  y  z  are 7  8  9 counter is 3 x  y  z  are 7  8  9 counter is 4 x  y  z  are 7  8  9 counter is 5 x  y  z  are 7  8  9

User · Answer

I write a simple function to use static variables  def Static            get the func object by which Static   is called      from inspect import currentframe  getframeinfo     caller   currentframe   f back     func name   getframeinfo caller  2        print func name      caller   caller f back     func   caller f locals get          func name  caller f globals get              func name                          class StaticVars          def has self  varName               return hasattr self  varName          def declare self  varName  value               if not self has varName                   setattr self  varName  value       if hasattr func   quot staticVars quot            return func staticVars     else            add an attribute to func         func staticVars   StaticVars           return func staticVars  How to use  def myfunc arg       if Static   has  test1            Static   test    1     else          Static   test   1     print Static   test         declare   only takes effect in the first time for each static variable      Static   declare  test2   1      print Static   test2      Static   test2    1

User · Answer

A global declaration provides this functionality  In the example below  python 3 5 or greater to use the  f    the counter variable is defined outside of the function  Defining it as global in the function signifies that the  global  version outside of the function should be made available to the function  So each time the function runs  it modifies the value outside the function  preserving it beyond the function   counter   0  def foo        global counter     counter    1     print  counter is     format counter    foo    output   counter is 1  foo    output   counter is 2  foo    output   counter is 3

User · Answer

Many people have already suggested testing  hasattr   but there s a simpler answer   def func        func counter   getattr func   counter   0    1   No try except  no testing hasattr  just getattr with a default

User · Answer

Use a generator function to generate an iterator   def foo gen        n   0     while True          n  1         yield n   Then use it like  foo   foo gen   next for i in range 0 10       print foo     If you want an upper limit   def foo gen limit 100000       n   0     while n  lt  limit         n  1        yield n   If the iterator terminates  like the example above   you can also loop over it directly  like  for i in foo gen 20       print i   Of course  in these simple cases it s better to use xrange     Here is the documentation on the yield statement

User · Answer

The idiomatic way is to use a class  which can have attributes   If you need instances to not be separate  use a singleton   There are a number of ways you could fake or munge  static  variables into Python  one not mentioned so far is to have a mutable default argument   but this is not the Pythonic  idiomatic way to do it   Just use a class   Or possibly a generator  if your usage pattern fits

User · Answer

Python doesn t have static variables but you can fake it by defining a callable class object and then using it as a function  Also see this answer   class Foo object       Class variable  shared by all instances of this class   counter   0    def   call   self       Foo counter    1     print Foo counter    Create an object instance of class  Foo   called  foo  foo   Foo      Make calls to the    call    method  via the object s name itself foo    prints 1 foo    prints 2 foo    prints 3   Note that   call   makes an instance of a class  object  callable by its own name  That s why calling foo   above calls the class    call   method  From the documentation      Instances of arbitrary classes can be made callable by defining a   call     method in their class

User · Answer

A bit reversed  but this should work   def foo        foo counter    1     print  Counter is  d    foo counter foo counter   0   If you want the counter initialization code at the top instead of the bottom  you can create a decorator   def static vars   kwargs       def decorate func           for k in kwargs              setattr func  k  kwargs k           return func     return decorate   Then use the code like this    static vars counter 0  def foo        foo counter    1     print  Counter is  d    foo counter   It ll still require you to use the foo  prefix  unfortunately    Credit   ony

User · Answer

counter   0 def foo       global  counter     counter    1    print  counter is    counter   Python customarily uses underscores to indicate private variables  The only reason in C to declare the static variable inside the function is to hide it outside the function  which is not really idiomatic Python

User · Answer

Other solutions attach a counter attribute to the function  usually with convoluted logic to handle the initialization  This is inappropriate for new code   In Python 3  the right way is to use a nonlocal statement   counter   0 def foo        nonlocal counter     counter    1     print f counter is  counter      See PEP 3104 for the specification of the nonlocal statement   If the counter is intended to be private to the module  it should be named  counter instead

User · Answer

A bit reversed  but this should work   def foo        foo counter    1     print  Counter is  d    foo counter foo counter   0   If you want the counter initialization code at the top instead of the bottom  you can create a decorator   def static vars   kwargs       def decorate func           for k in kwargs              setattr func  k  kwargs k           return func     return decorate   Then use the code like this    static vars counter 0  def foo        foo counter    1     print  Counter is  d    foo counter   It ll still require you to use the foo  prefix  unfortunately    Credit   ony

User · Answer

counter   0 def foo       global  counter     counter    1    print  counter is    counter   Python customarily uses underscores to indicate private variables  The only reason in C to declare the static variable inside the function is to hide it outside the function  which is not really idiomatic Python

User · Answer

This answer builds on  claudiu  s  answer   I found that my code was getting less clear when I always had  to prepend the function name  whenever I intend to access a static variable   Namely  in my function code I would prefer to write   print statics foo    instead of  print my function name foo    So  my solution is to     add a statics attribute to the  function in the function scope  add a local variable statics as an alias to my function statics   from bunch import    def static vars   kwargs       def decorate func           statics   Bunch   kwargs          setattr func   statics   statics          return func     return decorate   static vars name    Martin   def my function        statics   my function statics     print  Hello   0   format statics name       Remark  My method uses a class named Bunch  which is a dictionary that supports  attribute-style access  a la JavaScript  see the original article about it  around 2000   It can be installed via pip install bunch  It can also be hand-written like so   class Bunch dict       def   init   self    kw           dict   init   self kw          self   dict     self

[python] What is the Python equivalent of static variables inside a function?

Examples related to python