Подтвердить что ты не робот

Python: передача переменных между функциями

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

Например, я назначаю целую кучу значений списку в одной функции, а затем хочу использовать этот список в другой функции позже:

list = []

def defineAList():
    list = ['1','2','3']
    print "For checking purposes: in defineAList, list is",list
    return list

def useTheList(list):
    print "For checking purposes: in useTheList, list is",list

def main():
    defineAList()
    useTheList(list)

main()

Основываясь на моем понимании аргументов функции, я бы ожидал, что это будет делать следующее:

  • Инициализировать "список" как пустой список; call main (это, по крайней мере, я знаю, что я прав...)
  • В пределах defineAList() назначьте определенные значения в список; затем переведите новый список обратно в main()
  • В main() вызовите useTheList (список)
  • Поскольку "список" включен в параметры функции useTheList, я бы ожидал, что useTheList теперь будет использовать список, как определено defineAList(), а не пустой список, определенный перед вызовом main.

Однако это, очевидно, ошибочное понимание. Мой выход:

For checking purposes: in defineAList, list is ['1', '2', '3']
For checking purposes: in useTheList, list is []

Итак, поскольку "возврат", очевидно, не делает то, что я думаю, что он делает, или, по крайней мере, это не так, как мне кажется, это должно... что это на самом деле делает? Не могли бы вы показать мне, используя этот пример, что мне нужно сделать, чтобы взять список из defineAList() и использовать его в useTheList()? Я стараюсь лучше понимать вещи, когда вижу, что они происходят, но многие примеры правильной передачи аргументов, которые я видел, также используют код, который мне еще не знаком, и в процессе выяснения того, что происходит, я "На самом деле я не разбираюсь в этой концепции. Я использую 2.7.

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

Спасибо!

4b9b3361

ОТВЕТЫ

Ответ 1

Это то, что на самом деле происходит:

global_list = []

def defineAList():
    local_list = ['1','2','3']
    print "For checking purposes: in defineAList, list is", local_list 
    return local_list 

def useTheList(passed_list):
    print "For checking purposes: in useTheList, list is", passed_list

def main():
    # returned list is ignored
    returned_list = defineAList()   

    # passed_list inside useTheList is set to global_list
    useTheList(global_list) 

main()

Это то, что вы хотите:

def defineAList():
    local_list = ['1','2','3']
    print "For checking purposes: in defineAList, list is", local_list 
    return local_list 

def useTheList(passed_list):
    print "For checking purposes: in useTheList, list is", passed_list

def main():
    # returned list is ignored
    returned_list = defineAList()   

    # passed_list inside useTheList is set to what is returned from defineAList
    useTheList(returned_list) 

main()

Вы даже можете пропустить временный returned_list и передать возвращаемое значение непосредственно на useTheList:

def main():
    # passed_list inside useTheList is set to what is returned from defineAList
    useTheList(defineAList())

Ответ 2

Вам просто не хватает одного критического шага. Вы должны явно передать возвращаемое значение во вторую функцию.

def main():
    l = defineAList()
    useTheList(l)

В качестве альтернативы:

def main():
    useTheList(defineAList())

Или (хотя вы не должны этого делать! Сначала это может показаться приятным, но глобалы просто вызывают у вас печаль в долгосрочной перспективе.):

l = []

def defineAList():
    global l
    l.extend(['1','2','3'])

def main():
    global l
    defineAList()
    useTheList(l)

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

Ответ 3

Ваше возвращение бесполезно, если вы не назначили его

list=defineAList()

Ответ 4

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

def defineAList():
    #list = ['1','2','3'] this creates a new list, named list in the current namespace.
    #same name, different list!

    list.extend['1', '2', '3', '4'] #this uses a method of the existing list, which is in an outer namespace
    print "For checking purposes: in defineAList, list is",list
    return list

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

def main():
    new_list = defineAList()
    useTheList(new_list)

Ответ 5

return возвращает значение. Неважно, какое имя вы дали этой ценности. Вернувшись, он просто "передает это", чтобы что-то еще могло его использовать. Если вы хотите использовать его, вы должны захватить его снаружи:

lst = defineAList()
useTheList(lst)

Возвращение list изнутри defineAList не означает "сделать так, чтобы вся остальная часть программы могла использовать эту переменную". Это означает "передать эту переменную и дать остальной программе шанс захватить ее и использовать". Вам нужно назначить это значение чему-либо вне функции, чтобы использовать его. Кроме того, из-за этого нет необходимости заранее определять ваш список с помощью list = []. Внутри defineAList вы создаете новый список и возвращаете его; этот список не имеет отношения к тому, который вы определили с помощью list = [] в начале.

Кстати, я изменил имя переменной с list на lst. Не рекомендуется использовать list как имя переменной, поскольку это уже имя встроенного типа Python. Если вы создадите свою собственную переменную под названием list, вы больше не сможете получить доступ к встроенной версии.

Ответ 6

передача переменной из одной функции в качестве аргумента в другие функции может быть выполнена следующим образом:

определите такие функции, как

def function1():
global a
a=input("Enter any number\t")

def function2(argument):
print ("this is the entered number - ",argument)

вызовите функции, подобные этому

function1()
function2(a)