Почему эти функции выполняются в словаре

Question

Я начинающий python, и я практикую простой класс вычислений.

Этот фрагмент кода предполагается, что при вводе пользователем 2 номера и 1 оператора в командной строке он покажет вам ответ. Мне просто интересно, почему он печатает 4 строки в функции add(), subtract(), multiply() и divide(). Я просто поместил их в словарь, а не называть их всех. Может ли кто-нибудь объяснить это мне, пожалуйста? Было бы здорово показать мне решение. Спасибо заранее!

Вот выход из окна мощности оболочки:

PS D:\misc\Code\python\mystuff> python .\CalculationTest.py 
Please input a number: 
>1 
Please input a operator(i.e. + - * /): 
>+ 
Please input another number: 
>2 
Adding 1 + 2   #why it shows these 4 lines? 
Subtracting 1 - 2 
Multiplying 1 * 2 
Dividing 1/2 
3 

и вот мой код:

class Calculation(object): 
def add(self, a, b): 
    print "Adding %d + %d" % (a, b) 
    return a + b 

def subtract(self, a, b): 
    print "Subtracting %d - %d" % (a, b) 
    return a - b 

def multiply(self, a, b): 
    print "Multiplying %d * %d" % (a, b) 
    return a * b 

def divide(self, a, b): 
    if b == 0: 
     print "Error" 
     exit(1) 
    else: 
     print "Dividing %d/%d" % (a, b) 
     return a/b 

def get_result(self, a, b, operator): 
    operation = { 
     "+" : self.add(a, b),  # I didn't mean to call these methods, 
     "-" : self.subtract(a, b), # but it seems that they ran. 
     "*" : self.multiply(a, b), 
     "/" : self.divide(a, b), 
    } 
    print operation[operator] 

if __name__ == "__main__": 
    print "Please input a number:" 
    numA = int(raw_input(">")) 

    print "Please input a operator(i.e. + - * /):" 
    operator = raw_input(">") 

    print "Please input another number:" 
    numB = int(raw_input(">")) 

    calc = Calculation() 
    #print calc.add(numA, numB) 
    calc.get_result(numA, numB, operator) 

Answer 1

Вы говорите, что не хотел вызывать методы. Но вы сделали. Вы пишете

self.add(a, b) 

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

Если вы хотите захватить метод вместо его вызова, вам нужно положить self.add в dict.

Затем, когда вы хотите вызвать метод, который вы сделать это следующим образом:

print operation[operator](a, b) 

На данный момент мы используем оператор вызова () и подачи параметров.

Собираем все вместе, ваша функция выглядит следующим образом:

def get_result(self, a, b, operator): 
    operation = { 
     "+" : self.add,  
     "-" : self.subtract, 
     "*" : self.multiply, 
     "/" : self.divide, 
    } 
    print operation[operator](a, b) 

Поскольку dict никогда не меняется, она может быть более разумным, чтобы сделать это будет атрибут класса и инициализирует его только один раз.

Это не выглядит так, как будто ваш пример здесь очень полезен. Вы не имеете в виду self в любом месте. Это говорит о том, что эти методы могут быть лучше, чем static methods.

Answer 2

ли это вместо:

def get_result(self, a, b, operator): 
    operation = { 
     "+" : self.add, 
     "-" : self.subtract, 
     "*" : self.multiply, 
     "/" : self.divide, 
    } 
    print operation[operator](a, b) 

Обратите внимание, как фактический вызов метода (с (a, b)) был перемещен в после создания словаря. То, как вы это делали, вы вызывали каждый из методов и сохраняли результаты в словаре, вместо того, чтобы хранить методы, а затем вызывать только тот, который вам нужен.

Answer 3

Следующий код:

operation = { 
    "+" : self.add(a, b),  # I didn't mean to call these methods, 
    "-" : self.subtract(a, b), # but it seems that they ran. 
    "*" : self.multiply(a, b), 
    "/" : self.divide(a, b), 
} 

охотно оценить все значения, потому что это путь питона работы.Вы хотите:

operation = { 
    "+" : self.add, 
    "-" : self.subtract, 
    "*" : self.multiply, 
    "/" : self.divide, 
} 

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

Если вы хотите ввести код в свой первоначальный стиль, вам нужен язык с ленивой семантикой оценки, такой как haskell.