Это все еще предложение , и оно выглядело бы следующим образом:
class A {
property = "value";
}
Кстати, когда вы хотите получить доступ к свойству класса (т. е. к собственному свойству объекта), вы 'll все еще нужно использовать this.property
:
class A {
property = "value";
constructor() {
console.log(this.property);
}
}
Если вы хотите использовать этот синтаксис сегодня, вам нужно использовать транспилер, например Babel .
Я бы сделал это следующим образом:
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))
Вы изменяете переменную a
, созданную в области функции test()
. Если вы хотите изменить фокус a
, вы можете сделать:
a = 15
def test():
global a
a = a + 1
print(a)
test()
global
решает непосредственную проблему, это плохая практика программирования, и вы не должны действительно преподавать ее как решение для новичков, не указывая также, что это и плохая практика, и ее легко избежать. global
действительно не должен использоваться кем-то, кто еще не полностью понимает, почему обычно это неправильно.
– Zero Piraeus
28 December 2016 в 22:33
# 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: ...
Область переменной является локальной для блока, если явно не определена ключевое слово global
. Существует другой способ доступа к глобальной переменной локальной функции с помощью функции globals
a = 15
def test():
a = globals()['a']
a += 10
print ( a )
test()
. В приведенном выше примере будет напечатан 25
, сохраняя глобальное значение неизменным i.e 15
.
Ваша ошибка не имеет ничего общего с уже определена ... Переменная действительна только внутри ее так называемой области действия: если вы создаете переменную в функции, она определяется только в этой функции.
def test():
x=17
print(x) # returns 17
test()
print(x) # results in an error.
Ошибка, которую вы получаете при попытке запустить код:
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
x
действительно получил заменен i>, а не изменен i> ... Я знаю. Я уже должен был покрыть справедливое место, чтобы правильно ответить на этот вопрос, и решил не открывать эту черту червей.
– Zero Piraeus
28 December 2016 в 22:37
def test(a): return a + 10
? – boardrider 30 December 2016 в 23:23