for-loop внутри функции в Python получает ошибку [duplicate]

Это все еще предложение , и оно выглядело бы следующим образом:

class A {
   property = "value";
}

Кстати, когда вы хотите получить доступ к свойству класса (т. е. к собственному свойству объекта), вы 'll все еще нужно использовать this.property:

class A {
    property = "value";

    constructor() {
        console.log(this.property);
    }
}

Если вы хотите использовать этот синтаксис сегодня, вам нужно использовать транспилер, например Babel .

18
задан approxiblue 29 December 2016 в 07:38
поделиться

6 ответов

Я бы сделал это следующим образом:

def test(a):
    a = a +10
    return a

print(test(15))

Обратите внимание, что в предложенной версии есть некоторые вещи, отличающиеся от ваших.

Во-первых, то, что я записал, создало бы функция, которая имеет в качестве входного значения значение a (в этом случае значение 15, когда мы вызываем функцию, уже определенную в последней строке), затем присваивает объекту a значение a (которое равно 15) плюс 10 , затем возвращает a (который был изменен и теперь равен 25) и, наконец, выдает результат из последней строки кода:

print(test(15))

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

Кроме того, я бы посоветовал вам привыкнуть к записи возврата внутри функции, а затем использовать печать, когда вы ее вызываете (так же, как я писал в последней строке кодирования: print(test(15))) вместо ее использования внутри функции. Лучше использовать печать только тогда, когда вы вызываете функцию и хотите увидеть, что делает функция на самом деле.

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

P.S. Вы можете сделать то же самое:

def test(a):
    a +=10      
    return a

print(test(15))
2
ответ дан americansanti 19 August 2018 в 08:58
поделиться

Вы изменяете переменную a, созданную в области функции test(). Если вы хотите изменить фокус a, вы можете сделать:

a = 15

def test():
    global a
    a = a + 1
    print(a)

test()
2
ответ дан d4vsanchez 19 August 2018 в 08:58
поделиться
  • 1
    Хотя использование global решает непосредственную проблему, это плохая практика программирования, и вы не должны действительно преподавать ее как решение для новичков, не указывая также, что это и плохая практика, и ее легко избежать. global действительно не должен использоваться кем-то, кто еще не полностью понимает, почему обычно это неправильно. – Zero Piraeus 28 December 2016 в 22:33
  • 2
    Вы правы, и я излагаю свои оправдания за то, что я не отрицаю, что вы используете глобальный подход. Я могу подтвердить свой ответ в один момент, чтобы выразить это. Спасибо. @ZeroPiraeus – d4vsanchez 28 December 2016 в 22:45
# All the mumbo jumbo aside, here is an experiment 
# to illustrate why this is something useful 
# in the language of Python:
a = 15    # This could be read-only, should check docs

def test_1():
    b = a + 10    # It is perfectly ok to use 'a'
    print(b)

def test_2():
    a = a + 10    # Refrain from attempting to change 'a'
    print(a)

test_1()    # No error
test_2()    # UnboundLocalError: ...
-3
ответ дан Down the Stream 19 August 2018 в 08:58
поделиться

Область переменной является локальной для блока, если явно не определена ключевое слово global. Существует другой способ доступа к глобальной переменной локальной функции с помощью функции globals

a = 15

def test():
    a = globals()['a']
    a += 10
    print ( a )

test()

. В приведенном выше примере будет напечатан 25, сохраняя глобальное значение неизменным i.e 15.

0
ответ дан MaNKuR 19 August 2018 в 08:58
поделиться

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

def test():
   x=17
   print(x) # returns 17

test()
print(x) # results in an error.
-5
ответ дан Nudin 19 August 2018 в 08:58
поделиться

Ошибка, которую вы получаете при попытке запустить код:

UnboundLocalError: local variable 'a' referenced before assignment

... который, на первый взгляд, кажется странным: ведь сначала в коде выше (a = 15) является назначением. Итак, что происходит?

На самом деле происходит две разные вещи, и ни одна из них не очевидна, если вы уже не знаете о них.

Прежде всего, у вас на самом деле есть два различные переменные:

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

Эти две переменные полностью не связаны друг с другом, хотя они одно и то же имя.

Переменная локальна для функции, если в ней есть оператор, назначающий ее внутри - например, ваша a = a +10 строка.

Тем не менее, ошибка все еще выглядит странно - в конце концов, самое первое, что вы делаете внутри test(), присваивается a, поэтому как его можно называть заранее?

Ответ заключается в том, что в инструкции присваивания Python оценивает все, что находится справа ide знака =, прежде чем назначать его имени с левой стороны - так что, хотя назначение записано сначала в вашем коде, a получает , на которое ссылается сначала в этой правой части: a +10.

Есть два способа обойти это. Во-первых, чтобы сказать Python, что вы действительно хотите, чтобы a внутри test() были одинаковыми a в глобальной области:

def test():
    global a
    a = a + 10
    print(a)

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

Лучше всего передать переменные в качестве аргументов для функций, например:

a = 15

def test(x):
    x = x + 10
    print(x)

test(a)

Обратите внимание, что имя не должно быть одинаковым - ваше новое определение test() просто говорит, что он принимает значение, а затем что-то делает с ним. Вы можете передать все, что захотите - это может быть a, или число 7, или что-то еще. Фактически, ваш код всегда будет легче понять, если вы попытаетесь избежать наличия переменных с тем же именем в разных областях.

Если вы играете с приведенным выше кодом, вы заметите что-то интересное:

>>> a = 15
>>> test(a)
25
>>> a
15

... a не изменился! Это потому, что, хотя вы передали его в test(), и его присвоили x, он был изменен x, оставив только оригинальный a.

Если вы хотите фактически изменить a, вам нужно вернуть измененную функцию x из функции, а затем переназначить ее обратно на a снаружи:

>>> a = 15
>>> 
>>> def test(x):
...     x = x + 10
...     print(x)
...     return x
... 
>>> a = test(a)
25
>>> a
25
22
ответ дан Zero Piraeus 19 August 2018 в 08:58
поделиться
  • 1
    Прежде чем кто-нибудь отметит, что x действительно получил заменен , а не изменен ... Я знаю. Я уже должен был покрыть справедливое место, чтобы правильно ответить на этот вопрос, и решил не открывать эту черту червей. – Zero Piraeus 28 December 2016 в 22:37
Другие вопросы по тегам:

Похожие вопросы: