Python - базовая обработка переменных из funcs

Question

Когда я путаюсь, пытаясь научиться кодировать (на python), я сталкиваюсь с той же проблемой, с которой часто сталкиваюсь.

Как правильно передавать переменные в функции и из них.

В этом примере я хочу создать новую переменную внутри процесса функции, но я не знаю, как вернуть ее правильно (этот метод не работает.)

a = "foo"
def func_1():
 b = "bar"
 print a,b
 return (b)
func_1()
print b 

Я ожидаю, что b будет доступен после вызова функции, так как я его возвратил ... Я ценю это, не понимая, как правильно реализовывать / управлять переменными

Спасибо.

Answer 1

Я думаю, это то, что вы хотите сделать:

a = "foo"
def func_1():
 b = "bar"
 print a,b
 return b     # Took out parenthasis
returned_b = func_1()  # Added variable to hold the returned "b"
print returned_b 

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

Пара других вещей.

В строке a = "foo" a - это глобальныйпеременная.Это часто осуждается в программировании, потому что это может создать путаницу (хотя я чувствую, что это может быть использовано в частности в Python).

Похоже, у вас возникают проблемы с пониманием аспекта работы переменных, называемого 'объем'.Когда вы объявили переменную b внутри func_1(), у нее была только область действия функции.После выхода из функции переменная больше не существует, если только вы не вернули значение И не сохранили его в другой переменной, которая, возможно, по совпадению также была вызвана b.

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

Вот пример того, как может быть настроена «нормальная» программа:

def main():                 # Calling main() "runs" the program
   a = add(1,2)
   print a

def add(first, second):     # functions are normally declared outside of other functions, 
   result = first + second  #  that way, they can be used anywhere
   return result

Answer 2

Вызовы функций являются выражениями.Как и любое выражение, они имеют значение.Если вы никому не назначаете значение, оно теряется.

def add(a, b):
    result = a + b
    return result

four = add(2, 2)

Любые локальные переменные функции (например, a, b и result в приведенном выше случае) не являютсявидимы за пределами функции, то есть они являются локальными для функции.

Значением вызова функции является значение, которое было передано оператору return внутри функции.В данном случае это значение локальной переменной result.

Answer 3

Я думаю, вы имеете в виду, как получить доступ к значениям, которые я возвращаю из функции.

Скажем, у вас есть функция:

def func_1():
    b = 1
    return b

Если вы хотите получить возвращаемое значение из этой функции, установите некоторую переменную, равную ей, например:

someVariable = func_1() #func_1 executes it's code, and returns the value contained in b

Вы передаете аргументы функциям, помещая их в скобки в строке объявления функции:

a = "foo"

def func_1(some_foo): #here some_foo represents a variable you are passing to func_1
    b = "bar"
    print some_foo, b #now you're referencing the variable you passed
    return b

#Now you call the function like this:
func_1(a) #passing a (which equals "foo")

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

def func_1(some_foo1, some_foo2,...):

Также важно помнить, что переменные, объявленные / инициализированные внутри функции, доступны только внутри этого функционального блока. Поэтому:

def func_1(some_foo1):
    print some_foo1

a = some_foo1 #Doesn't work. The variable some_foo1 doesn't exist outside of `func_1`

Answer 4

b внутри func_1() является локальным для функции и недоступно за пределами функции. Вам необходимо присвоить возвращаемое значение функции func_1() имени переменной в основном теле.

b = func_1()
print b

Answer 5

Вот ваш пример изменения:

a = "foo"
def func_1():
    b = "bar"
    print a,b
    return b
b = func_1()
print b

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

Альтернативным подходом было бы использование глобальной (не локальной) переменной внутри функции.Для этого вам нужно объявить его глобальным внутри функции:

a = "foo"
def func_1():
    global b
    b = "bar"
    print a,b
func_1()
print b

Answer 6

Вы вернули его, но никому не присвоили:

def func_1():
    b = "bar"
    a = 2
    return a, b

a, b = func_1()
print b

Answer 7

Я ожидаю, что b будет доступен после вызова функции, так как я вернул его

Фундаментальное недоразумение: вы не возвращаете переменную, вы возвращаете значение. Переменные - это метки (имена) для значений. Внутри функции у вас есть имя b для значения "foo". Это имя используется для ссылки на значение, чтобы вы могли его вернуть.

Снаружи, чтобы использовать это значение, вы должны что-то с ним сделать. Вызов функции - func_1() - является заменой, в каком бы выражении оно ни содержалось, для возвращаемого значения. Таким образом, строка кода, подобная func_1(), сама по себе ничего не делает видимой: у вас есть выражение, которое оценивается как "foo", но тогда ничего не делается с "foo".

Вы можете, например, print(func_1()) отобразить строку. Вы можете присвоить возвращаемое значение другой переменной: c = func_1(). Теперь c - это имя для возвращенного значения "foo". Вы можете использовать вызов функции как часть большего выражения: c = func_1() + "bar" - теперь c - это имя для строки "foobar", созданной путем объединения строки, возвращаемой из функции, с непосредственно указанной.

С другой стороны: чтобы получить информацию в функции, вы должны передать ее в качестве параметра. Это значения, которые заключаются в круглые скобки: когда вы пишете функцию, вы помещаете имена аргументов (переменные другого типа) в круглые скобки, а когда вы вызываете функцию, вы помещаете параметры, с которыми вы вызываете функцию (выражения которые предоставляют значения). Теперь внутри функции при каждом вызове аргументы будут ссылаться на значения параметров.

Давайте рассмотрим простой пример. Мы сделаем функцию, которая добавляет "bar" к входной строке, и вызовем ее несколько раз.

def add_bar(to):
    return to + "bar"

Обратите внимание, как мы можем вернуть любое выражение. Когда функция вызывается, выражение вычисляется, соединяя переданную строку аргумента to с константой "bar", и полученное значение возвращается. Здесь нет переменной, представляющей все возвращаемое значение, потому что мы снова возвращаем значение, а не переменную.

Теперь мы можем назвать это. Опять же, параметром может быть любое выражение - так что константа:

add_bar("foo")

или переменная, которой мы ранее присвоили значение:

my_string = "sand"
add_bar(my_string)

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

add_bar(add_bar("bar ") + " ")

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

print("I want a " + add_bar("chocolate") + ".")