你可能在谈论一个可调用对象。

class MyFunction( object ):
    def __init__( self ):
        self.rememberThis= dict()
    def __call__( self, arg1, arg2 ):
        # do something
        rememberThis['a'] = arg1
        return someValue

myFunction= MyFunction()

从那时起，使用myFunction作为一个简单的函数。您可以使用myFunction.rememberThis访问rememberThis字典。

你可以使用static variable：

def foo(k, v):
  foo.a[k] = v
foo.a = {'a': 1, 'b': 2, 'c': 3}

foo('a', 100)
foo('b', 200)

print foo.a

与其在代码基础上强制使用全局变量（这可能是调用者的决定），我更喜欢保持与函数示例相关的状态的想法。类对此很好，但不能很好地传达您试图完成的内容，并且可能有点冗长。在我看来，利用闭包要干净得多。

def function_the_world_sees():
    a = {'a':1,'b':2,'c':3}

    def actual_function(arg0, arg1):
        a[arg0] = arg1
        return a

    return actual_function
stateful_function = function_the_world_sees()

stateful_function("b", 100)    
stateful_function("b", 200)

要记住的主要注意事项是，当你在“actual_function”中进行赋值时，它们发生在“actual_function”中。这意味着你不能将a重新赋值给不同的变量。我使用的解决方法是将我计划重新赋值的所有变量放入每个变量的单个元素列表或字典中。

如果'a'是在函数内部创建的。它将超出作用域。只需在函数外部创建它（并且在函数被调用之前）。通过这样做，列表/散列不会在程序离开函数后被删除。

a = {'a':1,'b':2,'c':3}

# call you funciton here

在我看来，这个问题没有一个优雅的答案。选项是可调用对象，默认值和属性hacks。可调用对象是正确的答案，但它们为另一种语言中的单个“静态”声明带来了很多结构。默认值是代码的一个小变化，但是它很笨拙，可能会让一个新的Python程序员在看你的代码时感到困惑。我不喜欢它们，因为它们的存在并没有对任何可能在看你的API的人隐藏。
我通常使用属性破解。我的首选方法是：

def myfunct():
    if not hasattr(myfunct, 'state'): myfunct.state = list()
    # access myfunct.state in the body however you want

这将状态声明保留在函数的第一行，并将myfunct作为函数。缺点是每次调用函数时都要进行属性检查。这几乎肯定不会成为大多数代码的瓶颈。

你可以使用Python的默认参数行为来“作弊”。默认参数只计算一次;它们被重复用于函数的每次调用。

>>> def testFunction(persistent_dict={'a': 0}):
...     persistent_dict['a'] += 1
...     print persistent_dict['a']
...
>>> testFunction()
1
>>> testFunction()
2

这不是最优雅的解决方案;如果有人调用这个函数并传入一个参数，它将覆盖默认值，这可能不是你想要的。
如果你只是想用一种快速的方法来得到结果，这是可行的。如果你正在做一些更复杂的事情，最好像S. Lott提到的那样把它分解到一个类中。
编辑：重命名字典，这样它就不会隐藏内置的dict，如下面的评论。

就我个人而言，我喜欢global语句的想法，它不引入全局变量，而是声明一个局部标识符实际上引用全局名称空间中的标识符。

d = dict()
l = list()
def foo(bar, baz):
    global d
    global l
    l.append(bar, baz)
    d[bar] = baz

在python 3.0中也有一个“nonlocal”语句。