Как поддерживать списки и словари между вызовами функций в Python?

Вы можете использовать статическая переменная:

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

Если внутри функции создается 'a'. Это выходит за рамки. Просто создайте его вне функции (и до вызова функции). При этом список / хэш не будет удален после выхода программы из функции.

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

# call you funciton here

Возможно, вы говорите о вызываемом объекте.

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

myFunction= MyFunction()

С этого момента используйте myFunction как простую функцию. Вы можете получить доступ к словарю rememberThis с помощью myFunction.rememberThis.

Вы можете «обмануть», используя поведение Python для аргументов по умолчанию. Аргументы по умолчанию оцениваются только один раз; они повторно используются для каждого вызова функции.

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

Это не самое элегантное решение; если кто-то вызывает функцию и передает параметр, он переопределит значение по умолчанию, что, вероятно, не то, что вам нужно.

Если вам просто нужен быстрый и грязный способ получить результаты, это сработает. Если вы делаете что-то более сложное, возможно, лучше вынести это в класс, как упомянул С. Лотт.

Обновлено: переименовал словарь, чтобы он не скрывал встроенный dict в соответствии с комментарием ниже.

Вместо того, чтобы навязывать глобальные переменные в базе кода (это может быть решением вызывающей стороны), я предпочитаю сохранять состояние, связанное с экземпляром функции. Класс хорош для этого, но плохо передает то, что вы пытаетесь выполнить, и может быть немного многословным. На мой взгляд, использование закрытий намного чище.

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 другой переменной. Обход, который я использую, заключается в том, чтобы поместить все свои переменные, которые я планирую переназначить, либо в отдельный список элементов для каждой переменной, либо в словарь.

На мой взгляд, на этот вопрос нет элегантного ответа. Возможные варианты - это вызываемые объекты, значения по умолчанию и взлом атрибутов. Вызываемые объекты - правильный ответ, но они привносят много структуры для того, что было бы одним «статическим» объявлением на другом языке. Значения по умолчанию - это незначительное изменение кода, но оно непонятно и может сбить с толку нового программиста на Python, смотрящего на ваш код. Мне они не нравятся, потому что их существование не скрыто от тех, кто может взглянуть на ваш API.

Я обычно использую хак атрибутов. Мой предпочтительный метод:

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

Это сохраняет объявление состояния в первой строке функции, которой оно принадлежит, а также сохраняет myfunct как функцию. Обратной стороной является то, что вы выполняете проверку атрибутов каждый раз, когда вызываете функцию. Это почти наверняка не будет узким местом для большей части кода.

Лично мне нравится идея глобального заявления. Он не вводит глобальную переменную, но утверждает, что локальный идентификатор фактически относится к идентификатору в глобальном пространстве имен.

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

В python 3.0 также есть «нелокальный» оператор.