static effect on python

how we can construct static effect on python instead of using class and global ?

not like that one :

global a
a = []

#simple ex ;
fonk ( a , b , d) 

   x =  1 

   a.append ( x) 

EDIT: I want to create temporary memory , if I exit the function namely fonk , I want to save change as list on temporary memory . We can do that demand only put static keyword in front of data type but in python , we dont have static, so I want that effect in python . Therefore , how can I do ?

As above code say "a" re开发者_运维技巧presents temporary memory

Default values for function arguments are evaluated once, at function definition time, so if you put a mutable object there, it will live across calls. Can be a gotcha, but very useful for caches and similar things static is often used for in other languages. Of course callers can override your cache in this case - but that's not a bad thing, they won't unless they have good reasons and in that case you should allow them to.

Example (this one is usually found in "gotchas" question instead ^^):

def append_and_return_static_list(item, items=[]):
    items.append(item)
    return items

append_and_return_static_list(0)
append_and_return_static_list(1)
print append_and_return_static_list(2) #=> [0,1,2]

Now, if you absolutely don't want to go that way, you still have other possibilities: You can create a variable outside the function and put the object you want to share there. You should propably prefix the name with a single underscore if you want it to be considered private to that place (not compiler-enforced-private but convention-and-survival-instinct-enforced).

Example (not the best code, the above is better in almost all cases):

_items = []
def append_and_return_static_list(item):
    _items.append(item)
    return _items

append_and_return_static_list(0)
append_and_return_static_list(1)
print append_and_return_static_list(2) #=> [0,1,2]

Attributes defined in global scope or in class scope are effectively static since modules are treated as singletons and by extension class definitions are singletons within a particular module global scope. (This explanation glosses over the dynamic features of Python that can change this behavior)

The global keyword is used within a local scope to disambiguate assignment. It's a declaration that the attribute name belongs to the enclosing global scope.

In your (broken) example you don't even need to use the global keyword since you are not using assignment, you are calling the append() method of a - no disambiguation is required.

An illustrative example of what global is used for:

>>> a = []
>>> def fonk():
...     a = [1]
...
>>> print a
[]
>>> fonk()
>>> print a
[]
>>>
>>> def fonk2():
...     global a
...     a = [2]
...
>>> print a
[]
>>> fonk2()
>>> print a
[2]

EDIT: I guess I missed the point of the question (do not do it via global and classes), but I don't understand the objection especially when it seems that the example code was broken.