объем переменной Python
Я преподаю мой сам Python, и я переводил некоторый пример кода в это
class Student(object):
def __init__( self, name, a,b,c ):
self.name = name
self.a = a
self.b = b
self.c = c
def average(self):
return ( a+b+c ) / 3.0
Который является в значительной степени моим намеченным определением класса
Позже в основном методе я создаю экземпляр и называю его a
if __name__ == "__main__" :
a = Student( "Oscar", 10, 10, 10 )
Это - то, как я узнаю что переменная a объявленный в main доступно методу average и заставить тот метод работать, я должен ввести self.a + self.b + self.c вместо этого
Каково объяснение этого?
Я нашел связанные вопросы, но я действительно не знаю, ли они о том же
3 ответа
Открытые имена (например, a , b , ] c ) всегда имеют локальную или глобальную область видимости (за исключением вложенных функций, которых нет в вашем коде). Обоснование этого состоит в том, что добавление дополнительных областей может без необходимости усложнить ситуацию - например, если в вашем self.a = a пустое имя a может быть ограничено, чтобы означать то, что вам кажется (эквивалент self.a ), тогда само присвоение будет бессмысленным (присвоение имени самому себе), поэтому вам потребуются дополнительные сложные правила.
Простое использование квалифицированных имен (например, self.a ), когда вам нужно что-то отличное от простого, понятного и оптимизированного поведения barenames, - это, безусловно, самый простой подход - отлично работающий, никаких сложных правил , и позволяет компилятору эффективно оптимизировать вещи (поскольку, например, область действия barename всегда определяется лексически, не зависит от динамически изменяющихся характеристик среды). Таким образом, помимо, возможно, ностальгии по другому языку с более сложными правилами области видимости, на самом деле нет причин усложнять семантику простых имен.
Есть несколько причин, но главная из них из дзэн Python: «Явное лучше, чем неявное». В таком языке, как C ++, метод класса всегда имеет неявный аргумент this , который помещается в стек каждый раз при вызове метода.В этом случае, когда существует переменная экземпляра b , а также глобальная переменная b , тогда пользователь может просто сослаться на b , ссылаясь на одну, не осознавая, что другой будет использоваться. Итак, Python вынуждает вас четко указывать свою область действия, чтобы избежать путаницы.
Вместе с тем есть и другие причины. Например, я могу определить функцию вне класса, а затем присоединить ее к классу во время выполнения. Например:
def log(self):
print "some library function requires all objects to have a log method"
print "unfortunately we're using the Student class, which doesn't have one"
print "this class is defined in a separate library, so we can't add the method"
print "fortunately, we can just add the method dynamically at runtime"
Student.log = log
Здесь тот факт, что self является явным, делает тривиальным определение функции вне класса, а затем присоединение ее к этому классу. Я не делаю такие вещи невероятно часто, но когда я это делаю, это ОЧЕНЬ полезно.
Вот еще более сложный пример; предположим, мы хотим определить класс внутри другого класса, например, для целей модульного тестирования:
class SomeUnitTests(TestCase):
def test_something(self):
class SomeMockObject(SomeActualObject):
def foo(self2):
self.assertEqual(self2.x, SOME_CONSTANT)
some_lib.do_something_with(SomeMockObject)
Здесь наличие явного self (которое мы можем называть как угодно, оно не обязательно должно быть self) позволяет чтобы различать себя внутреннего и внешнего классов. Опять же, я делаю это не часто, но когда делаю, это невероятно полезно.
Все переменные экземпляра должны вызываться с использованием self