Начало
Здравствуйте, в предыдущей статье я показывал как сделать игру на python, а сейчас мы посмотри как сделать простой калькулятор на python tkinter.
Создаём окно 485 на 550. Размеры не важны, мне понравились такие. Так же указываем, что окно не будет изменяться.
from tkinter import *
class Main(Frame):
def __init__(self, root):
super(Main, self).__init__(root)
self.build()
def build(self):
pass
def logicalc(self, operation):
pass
def update():
pass
if __name__ == '__main__':
root = Tk()
root["bg"] = "#000"
root.geometry("485x550+200+200")
root.title("Калькулятор")
root.resizable(False, False)
app = Main(root)
app.pack()
root.mainloop()
Отлично, идём дальше.
Делаем кнопочки
В методе build создаём такой список:
btns = [
"C", "DEL", "*", "=",
"1", "2", "3", "/",
"4", "5", "6", "+",
"7", "8", "9", "-",
"+/-", "0", "%", "X^2"
]
Он отвечает за все кнопки, отображающиеся у нас в окне.
Мы создали список, теперь проходимся циклом и отображаем эти кнопки. Для этого в том же методе пишем следующее:
x = 10
y = 140
for bt in btns:
com = lambda x=bt: self.logicalc(x)
Button(text=bt, bg="#FFF",
font=("Times New Roman", 15),
command=com).place(x=x, y=y,
width=115,
height=79)
x += 117
if x > 400:
x = 10
y += 81
Замечательно, у нас есть кнопочки. Добавляем надпись с выводом результата. Я хочу что бы текст был слева, следовательно, аттрибутов выравнивания текста писать не нужно.
self.formula = "0"
self.lbl = Label(text=self.formula, font=("Times New Roman", 21, "bold"),
bg="#000", foreground="#FFF")
self.lbl.place(x=11, y=50)
Пишем логику
def logicalc(self, operation):
if operation == "C":
self.formula = ""
elif operation == "DEL":
self.formula = self.formula[0:-1]
elif operation == "X^2":
self.formula = str((eval(self.formula))**2)
elif operation == "=":
self.formula = str(eval(self.formula))
else:
if self.formula == "0":
self.formula = ""
self.formula += operation
self.update()
def update(self):
if self.formula == "":
self.formula = "0"
self.lbl.configure(text=self.formula)
Так, как у нас нет ввода с клавиатуры, мы можем позволить себе сделать так, просто проверить на спец. кнопки (C, DEL, =) и в остальных случаях просто добавить это к формуле.
У этого калькулятора множество недочетов, но мы и не стремились сделать его идеальным.
Прошу прощения за ошибки в статье. Пишите, я исправлюсь.
Полный код моей версии калькулятора:
from tkinter import *
class Main(Frame):
def __init__(self, root):
super(Main, self).__init__(root)
self.build()
def build(self):
self.formula = "0"
self.lbl = Label(text=self.formula, font=("Times New Roman", 21, "bold"), bg="#000", foreground="#FFF")
self.lbl.place(x=11, y=50)
btns = [
"C", "DEL", "*", "=",
"1", "2", "3", "/",
"4", "5", "6", "+",
"7", "8", "9", "-",
"(", "0", ")", "X^2"
]
x = 10
y = 140
for bt in btns:
com = lambda x=bt: self.logicalc(x)
Button(text=bt, bg="#FFF",
font=("Times New Roman", 15),
command=com).place(x=x, y=y,
width=115,
height=79)
x += 117
if x > 400:
x = 10
y += 81
def logicalc(self, operation):
if operation == "C":
self.formula = ""
elif operation == "DEL":
self.formula = self.formula[0:-1]
elif operation == "X^2":
self.formula = str((eval(self.formula))**2)
elif operation == "=":
self.formula = str(eval(self.formula))
else:
if self.formula == "0":
self.formula = ""
self.formula += operation
self.update()
def update(self):
if self.formula == "":
self.formula = "0"
self.lbl.configure(text=self.formula)
if __name__ == '__main__':
root = Tk()
root["bg"] = "#000"
root.geometry("485x550+200+200")
root.title("Калькулятор")
root.resizable(False, False)
app = Main(root)
app.pack()
root.mainloop()
Только зарегистрированные пользователи могут участвовать в опросе. Войдите, пожалуйста.
Как бы вы оценили грамотность написания данной статьи?
Проголосовали 167 пользователей.
Воздержались 79 пользователей.
В последние годы цифровой мир всё больше использует облачные системы. Сервисы вроде timeweb.cloud доказали своё удобство и надёжность, мгновенно обрабатывая гигантские объёмы информации. Но сегодня мы вспомним основы современных технологий и расскажем вам, как написать программу-калькулятор своими руками.
Кстати, в официальном канале Timeweb Cloud собрали комьюнити из специалистов, которые говорят про IT-тренды, делятся полезными инструкциями и даже приглашают к себе работать.
В начале работы над калькулятором вспомним, из чего он состоит и как он работает. Мы будем писать аналог простого настольного калькулятора, который есть у каждого школьника. Прочитав эту статью и выполнив все задания, вы получите готовый код на питоне простейшего калькулятора.
У настольного калькулятора есть:
- Кнопки с цифрами
- Кнопки с математическими операциями
- Дисплей
- Микросхемки внутри
В функции настольного калькулятора входит:
- Сложение
- Вычитание
- Деление
- Умножение
- Сброс операции
- Сохранение результата
- Вычисление процента
- Взятие корня числа
Для понимания принципа написания калькулятора возьмем из этого списка минимальный набор функций:
- Ввод чисел
- Вывод результата
- Сложение
- Вычитание
- Деление
- Умножение
Код можно писать прямо в онлайн-редакторе.
Например:
- https://www.online-python.com/
- https://replit.com/languages/python3
Примеры кода математических операций
Математические операции, которые будем использовать:
2+2
4 10-5
5
3*3
9
12/4
3.0
Вывод значения
Чтобы видеть результат, его нужно вывести на экран. Для этого существует функция print(), которая выводит аргументы в скобках в консоль.
print(4 * 4)
16Эта функция будет аналогом дисплея нашего калькулятора.
Сохранение результата в переменную
Чтобы не производить вычисления внутри функции print(), будем хранить их в переменной.
result = 16 / 8Далее мы сможем вывести в консоль значение переменной.
print(result)
2.0Чтение строк
С дисплеем разобрались, теперь используем Python 3 для создания ввода с клавиатуры. У нас есть кнопки с цифрами на клавиатуре, чтобы передать их программе, существует функция input(). При вызове она считывает любые символы с клавиатуры до тех пор, пока не будет нажата клавиша Enter. После этого она возвращает результат в виде строки из введённых символов. Давайте посмотрим, как это работает:
text = input() # Hi
HiВыведем результат на экран.
print(text)
HiЕсли передать внутрь функции input() текст, то он выводится на экран перед тем, как начнётся считывание строки.
username = input('Enter your name: ') # Иван
print(username)
Enter your name: Иван
ИванОбъединение и форматирование строк
Чтобы вывод данных стал более дружелюбным, мы можем добавить пояснения к ним. Для этого используем объединение (конкатенацию) строк.
print('Hello, ' + username + '!')
Hello, Иван!Ещё один способ объединения текста с данными — использование форматированных строк. Для этого перед кавычками необходимо поставить символ f, а данные записывать прямо внутри строки в фигурных скобках. Такой функционал появился с версии Python 3.6.0.
print(f'Hello, {username}!')
Hello, Иван!Перевод строк в число
Теперь, когда мы умеем производить математические операции, считывать данные с клавиатуры и красиво выводить результат в консоль, давайте наконец-то напишем первую версию калькулятора! Для простоты пусть он пока будет только складывать числа, но это уже будет готовый пример кода программы на Питон.
# Считываем данныеa = input('Введите первое число: ')
b = input('Введите второе число: ') # Производим вычисления
result = a + b
# Выводим результат в консоль
print(f'Сумма чисел {a} и {b} равняется: {result}')
Введите первое число: 12
Введите второе число: 55
Сумма чисел 12 и 55 равняется: 1255
Что-то пошло не так. Числа не сложились, а объединились как текст. Дело в том, что input() в Python возвращает ввод строки с клавиатуры, даже если вы вводили только числа. Такое поведение более явное, что соответствует философии Python: «Явное лучше, чем неявное». Для того чтобы исправить возникшую ошибку, используем функцию перевода строки в число: int(). Посмотрим на примере, как работает num int input:
num = int(input())
print(num + 10)
32
42Отредактируем нашу программу.
# Считываем данныеa = int(input('Введите первое число: '))
b = int(input('Введите второе число: ')) # Производим вычисления
result = a + b
# Выводим результат в консоль
print(f'Сумма чисел {a} и {b} равняется: {result}')
Введите первое число: 12
Введите второе число: 55
Сумма чисел 12 и 55 равняется: 67
Обработка некорректных данных
Но что если пользователь введёт не числа, а буквы или другие символы? При попытке перевести такую строку в число Python выдаст ошибку и остановит выполнение программы.
int(input('Введите первое число: '))
Введите первое число: abc
------------------------------------------------------------------------ ValueError Traceback (most recent call last)
C:Tempipykernel_5404317567321.py in <module>
----> 1 int(input('Введите первое число: '))
ValueError: invalid literal for int() with base 10: 'abc'
Такие ошибки можно оперативно определять и менять стандартное поведение при их возникновении, например предлагать пользователю ввести число заново. Но это отдельная тема для разговора, поэтому в контексте этой статьи условимся, что пользователь всегда вводит корректные данные.
Создание функций
Итак, у нас есть практически все компоненты для того, чтобы написать полноценный калькулятор. Давайте расширим функционал текущей версии до выполнения всех математических операций, которые мы запланировали:
- Сложение
- Вычитание
- Деление
- Умножение
Чтобы улучшить читаемость кода, разделим эти операции на отдельные функции. Смотрите, как это делается на примере суммы.
# Сложение
def sum(a, b):
result = a + b
return resultОпределяем функцию с помощью ключевого слова def, пишем её название и в скобках указываем, какие параметры она принимает. Далее в теле функции пишем то, что она должна выполнять и возвращаем результат с помощью ключевого слова return .
Обратите внимание, что тело функции записывается с отступами строки — таковы правила создания функции. В противном случае будет ошибка.
def test():
print(123)
File "C:Tempipykernel_5404353670293.py", line 2
print(123)
^
IndentationError: expected an indented blockРезультат работы функции можно также сохранить в переменную для дальнейшего использования.
x = sum(10, 15)
print(x)
25Аналогичным образом создадим остальные функции вычисления.
# Вычитаниеdef subtract(a, b):
result = a - b
return result # Умножение
def multiply(a, b):
result = a * b
return result
# Деление
def divide(a, b):
result = a / b
return result
Условные операторы
Функции операций готовы. Осталось написать простой код на питоне, который предоставит пользователю возможность выбора этих операций. Будем использовать уже знакомый нам ввод с клавиатуры и условные операторы. Условные операторы работают очень просто. Их название говорит само за себя.
Если условие истинно, например 2 == 2,
то выполняем один блок кода ,
иначе
выполняем другой блок кодаНа месте двоек могут быть переменные, функции, возвращающие значения, строки и даже математические операции. Посмотрим, как это выглядит в коде на примере проверки пароля. Предположим, что верный пароль: qwerty.
# спрашиваем у пользователя пароль
password = input('Введите пароль: ')
# Проверяем, соответствует ли он задуманному нами
if password == 'qwerty':
print('Верно!')
else:
print('Неправильный пароль')
Введите пароль: йцукен
Неправильный пароль # спрашиваем у пользователя пароль
password = input('Введите пароль: ')
# Проверяем, соответствует ли он задуманному нами
if password == 'qwerty':
print('Верно!')
else:
print('Неправильный пароль')
Введите пароль: qwerty
Верно!
Обратите внимание, что блоки кода также пишутся с отступами, как и в функциях. Двоеточие также обязательно.
Сразу же применим полученные знания к нашему калькулятору. Будем спрашивать у пользователя, какую операцию он хочет совершить, и, в зависимости от ввода, вызывать соответствующую функцию вычисления. Для начала просто выведем текст выбранной операции или сообщение, что такой операции не существует. Следующим шагом заменим текст на вызов операции и объединим его с уже существующей логикой калькулятора.
# Подготовим сообщение для пользователя о доступных математических операциях.
# В тройных кавычках можно хранить многострочный текст.
message = '''
Пожалуйста, введите символ операции, которую вы хотите совершить и нажмите Enter: + : Сложение
- : Вычитание
/ : Деление
* : Умножение
Ваш выбор:
'''
# Запрашиваем у пользователя желаемое действие
operation = input(message)
# Выводим сообщение о выбранной операции или что она отсутствует
if operation == '+':
print('Сложение')
elif operation == '-':
print('Вычитание')
elif operation == '/':
print('Деление')
elif operation == '*':
print('Умножение')
else:
print('Неизвестная операция')
Пожалуйста, введите символ операции, которую вы хотите совершить и нажмите Enter:
+ : Сложение
- : Вычитание
/ : Деление
* : Умножение
Ваш выбор:
+
Сложение
Собираем всё в единое целое
Поместим всю логику вычислений внутрь функции, чтобы мы могли удобно обращаться к ней в коде скрипта.
def calculate(a, b, operation):
result = None if operation == '+':
result = sum(a, b)
elif operation == '-':
result = subtract(a, b)
elif operation == '/':
result = divide(a, b)
elif operation == '*':
result = multiply(a, b)
else:
print('Неизвестная операция')
return result
Также добавим функцию для запроса операции.
def ask_operation():
message = '''
Пожалуйста, введите символ операции, которую вы хотите совершить и нажмите Enter: + : Сложение
- : Вычитание
/ : Деление
* : Умножение
Ваш выбор:
'''
# Запрашиваем у пользователя желаемое действие
operation = input(message)
return operation
Теперь оборачиваем все этапы взаимодействия с калькулятором в условный корпус функции calculate.
def run_calculator():
# Запрашиваем данные
a = int(input('Введите первое число: '))
b = int(input('Введите второе число: ')) # Запрашиваем тип операции
operation = ask_operation()
# Производим вычисления
result = calculate(a, b, operation)
# Выводим результат в консоль
print(f'Результат вычислений: {result}')
Проверяем!
run_calculator()
Введите первое число: 15
Введите второе число: 15 Пожалуйста, введите символ операции, которую вы хотите совершить и нажмите Enter:
+ : Сложение
- : Вычитание
/ : Деление
* : Умножение
Ваш выбор:
*
Результат вычислений: 225
Работает! Поздравляем, только что вы написали свой калькулятор.
Расширение функционала и улучшение кода
Добавление операций
Благодаря тому, что функции вычисления вынесены в отдельные модули calculate python, мы можем с лёгкостью расширять функционал калькулятора.
Давайте добавим операцию возведения в степень.
def pow(a, b):
result = a ** b
return resultДобавляем операцию в функцию вычисления.
def calculate(a, b, operation):
result = None if operation == '+':
result = sum(a, b)
elif operation == '-':
result = subtract(a, b)
elif operation == '/':
result = divide(a, b)
elif operation == '*':
result = multiply(a, b)
# Возведение в степень
elif operation == '^' or operation == '**':
result = pow(a, b)
else:
print('Неизвестная операция')
return result
Также добавим пояснения в функцию запроса действия.
def ask_operation():
message = '''
Пожалуйста, введите символ операции, которую вы хотите совершить и нажмите Enter:
+ : Сложение
- : Вычитание
/ : Деление
* : Умножение
^ или ** : Возведение в степень
Ваш выбор: ''' # Запрашиваем у пользователя желаемое действие
operation = input(message)
return operation
Проверяем, запустив функцию run_calculator().
run_calculator()
Введите первое число: 2
Введите второе число: 8 Пожалуйста, введите символ операции, которую вы хотите совершить и нажмите Enter:
+ : Сложение
- : Вычитание
/ : Деление
* : Умножение
^ или ** : Возведение в степень
Ваш выбор: **
Результат вычислений: 256
Тестирование и обработка ошибок
Сейчас, если мы введём неизвестную операцию, калькулятор выдаст сообщение, что такой операции нет, и оставит всё, как есть. Более того, он выведет сообщения о полученном результате, которого по определению быть не должно. Давайте посмотрим:
run_calculator()
Введите первое число: 3
Введите второе число: 5 Пожалуйста, введите символ операции, которую вы хотите совершить и нажмите Enter:
+ : Сложение
- : Вычитание
/ : Деление
* : Умножение
^ или ** : Возведение в степень
Ваш выбор: &
Неизвестная операция
Результат вычислений: None
Ничего страшного не случилось, но и пользы никакой. Такой процесс, когда мы пробуем ввести в программу некорректные данные и наблюдать, как она реагирует, называется тестированием. Это отдельная профессия, но, так или иначе, элементарные тесты должен уметь делать любой программист-профессионал.
Циклы
Давайте изменим поведение программы и позволим пользователю повторно выбрать требуемую операцию.
Для этого поместим код с запросом операции в цикл while. Принцип его во многом схож с условными операторами. Он проверяет условие на истинность и, если оно истинно, выполняет блок кода. После выполнения цикл повторяется — проверка условия и выполнение тела цикла. Таким образом, чтобы цикл завершился, нам нужно изменить проверяемое условие на ложное. Выход из цикла — это очень важный момент. Если не продумать логику выхода из цикла, он может продолжаться бесконечно, что не всегда желательно.
Простой пример. Будем выводить в консоль всё, что введёт пользователь, до тех пор, пока не будет введена пустая строка.
text = None while text != '':
text = input('Напишите что-нибудь или оставьте строку пустой, чтобы закончить:n')
print(f'Вы ввели: {text}n')
print('Завершение программы')
Напишите что-нибудь или оставьте строку пустой, чтобы закончить:
123
Вы ввели: 123
Напишите что-нибудь или оставьте строку пустой, чтобы закончить:
test
Вы ввели: test
Напишите что-нибудь или оставьте строку пустой, чтобы закончить:
Вы ввели:
Завершение программы
Теперь применим это к калькулятору.
Для этого изменим функцию запроса операции ask_operation
def ask_operation():
message = '''
Пожалуйста, введите символ операции, которую вы хотите совершить и нажмите Enter:
+ : Сложение
- : Вычитание
/ : Деление
* : Умножение
^ или ** : Возведение в степень Ваш выбор: '''
# Создадим список с возможными операциями
correct_operations = ['+', '-', '/', '*', '^', '**']
# Первый раз запрашиваем у пользователя желаемое действие
operation = input(message)
# Запускаем цикл, если операции нет в списке
while operation not in correct_operations:
print('Такая операция недоступна. Повторите попытку.')
operation = input(message)
return operation
Вычисления не производятся до тех пор, пока не будет введена корректная операция. Тест пройден.
Заключение
Сегодня легко найти калькулятор на любой вкус: встроенные в различные приложения, сайты с калькуляторами, обычные физические калькуляторы, разнообразные инженерные модификации, включая такие интересные калькуляторы, как python ipcalc, позволяющий выполнять расчёты IP-подсети. Но что может быть лучше, чем вещь, сделанная и модернизированная своими руками?
20 декабря, 2016 12:13 пп
106 362 views
| 10 комментариев
Python
Язык программирования Python является отличным инструментом для обработки чисел и математических выражений. На основе этого качества можно создавать полезные программы.
В данном руководстве вам предлагается полезное упражнение: попробуйте написать простую программу командной строки для выполнения вычислений. Итак, в данном руководстве вы научитесь создавать простейший калькулятор в Python 3.
В руководстве используются математические операторы, переменные, условные выражения, функции.
Требования
Для выполнения руководства нужно установить Python 3 на локальную машину и развернуть среду разработки. Все необходимые инструкции можно найти здесь:
- Настройка локальной среды разработки для Python 3 в CentOS 7
- Настройка локальной среды разработки для Python 3 в Windows 10
- Настройка локальной среды разработки для Python 3 в Mac OS X
- Настройка локальной среды разработки для Python 3 в Ubuntu 16.04
1: Строка ввода
Для начала нужно написать строку ввода, с помощью которой пользователи смогут вводить данные для вычислений в калькуляторе.
Для этого используйте встроенную функцию input(), которая принимает сгенерированный пользователем ввод с клавиатуры. В круглых скобках функции input() можно передать строку. Пользовательскому вводу нужно присвоить переменную.
В данной программе пользователь сможет вводить два числа. Запрашивая ввод, нужно добавить пробел в конце строки, чтобы отделить ввод пользователя от строки программы.
number_1 = input('Enter your first number: ')
number_2 = input('Enter your second number: ')
Прежде чем запустить программу, сохраните файл. К примеру, назовём программу calculator.py. теперь можно запустить программу в окне терминала в среде разработки с помощью команды:
python calculator.py
Программа предложит вам ввести два числа:
Enter your first number: 5
Enter your second number: 7
На данный момент калькулятор принимает любые входные данные, не ограничиваясь числами: слова, символы, пробелы, даже enter. Это происходит потому, что функция input() принимает данные как строки и не знает, что в данном случае нужны только числа.
Чтобы программа могла выполнять математические вычисления, она не должна принимать никаких данных, кроме чисел.
В зависимости от предназначения калькулятора, программа может преобразовывать строки функции input() в целые числа или в числа с плавающей точкой. В данном случае целые числа подходят больше. Функцию input() нужно передать внутри функции int(), чтобы преобразовать ввод в целое число.
Читайте также:
Типы данных в Python 3
Преобразование типов данных в Python 3
number_1 = int(input('Enter your first number: '))
number_2 = int(input('Enter your second number: '))
Теперь попробуйте ввести два целых числа:
Enter your first number: 23
Enter your second number: 674
Все работает без ошибок. Однако если вы введёте символы, пробелы или буквы, программа вернёт ошибку:
Enter your first number: hello
Traceback (most recent call last):
File "testing.py", line 1, in <module>
number_1 = int(input('Enter your first number: '))
ValueError: invalid literal for int() with base 10: 'hello'
Итак, вы написали строку для ввода данных в программу.
Примечание: Попробуйте самостоятельно преобразовать входные данные в числа с плавающей точкой.
2: Добавление операторов
Теперь нужно добавить четыре базовых оператора: + (сложение), – (вычитание), * (умножение) и / (деление).
Программу лучше разрабатывать постепенно, чтобы иметь возможность протестировать её на каждом этапе.
Сначала добавьте оператор сложения. Поместите два числа в print, чтобы калькулятор отображал результат.
number_1 = int(input('Enter your first number: '))
number_2 = int(input('Enter your second number: '))
print(number_1 + number_2)
Запустите программу и попробуйте сложить два числа:
Enter your first number: 8
Enter your second number: 3
11
Теперь можно немного усложнить программу. Пусть кроме результата калькулятор также отображает числа, введенные пользователем.
Читайте также: Форматирование строк в Python 3
number_1 = int(input('Enter your first number: '))
number_2 = int(input('Enter your second number: '))
print('{} + {} = '.format(number_1, number_2))
print(number_1 + number_2)
Снова запустите программу и попробуйте ввести какие-нибудь числа:
Enter your first number: 90
Enter your second number: 717
90 + 717 =
807
Теперь пользователь сможет убедиться, что ввел правильные числа.
На данном этапе можно добавить остальные операторы, используя такой же формат:
number_1 = int(input('Enter your first number: '))
number_2 = int(input('Enter your second number: '))
# Addition
print('{} + {} = '.format(number_1, number_2))
print(number_1 + number_2)
# Subtraction
print('{} - {} = '.format(number_1, number_2))
print(number_1 - number_2)
# Multiplication
print('{} * {} = '.format(number_1, number_2))
print(number_1 * number_2)
# Division
print('{} / {} = '.format(number_1, number_2))
print(number_1 / number_2)
Теперь калькулятор может выполнять математические вычисления при помощи операторов +, -, * и /. Далее нужно ограничить количество операций, которые программа может выполнить за один раз.
3: Добавление условного оператора
Читайте также: Условные операторы в Python 3
Добавьте в начало программы calculator.py небольшое описание с перечнем доступных операций. Выбрав один из операторов, пользователь сообщит программе, что именно ей нужно будет делать.
'''
Please type in the math operation you would like to complete:
+ for addition
- for subtraction
* for multiplication
/ for division
'''
Примечание: На самом деле здесь можно использовать любые символы (например, 1 для сложения, b для вычитания и так далее).
Передайте строку внутри функции input() и присвойте переменную значению ввода (к примеру, это будет переменная operation).
operation = input('''
Please type in the math operation you would like to complete:
+ for addition
- for subtraction
* for multiplication
/ for division
''')
number_1 = int(input('Enter your first number: '))
number_2 = int(input('Enter your second number: '))
print('{} + {} = '.format(number_1, number_2))
print(number_1 + number_2)
print('{} - {} = '.format(number_1, number_2))
print(number_1 - number_2)
print('{} * {} = '.format(number_1, number_2))
print(number_1 * number_2)
print('{} / {} = '.format(number_1, number_2))
print(number_1 / number_2)
В эту строку пользователь может ввести любой из предложенных символов, но ничего не произойдёт. Чтобы программа работала, нужно добавить условный оператор. Оператор if будет отвечать за сложение, три оператора elif – за остальные операции; оператор else будет возвращать ошибку, если вместо предложенных операторов пользователь ввёл другой символ.
operation = input('''
Please type in the math operation you would like to complete:
+ for addition
- for subtraction
* for multiplication
/ for division
''')
number_1 = int(input('Enter your first number: '))
number_2 = int(input('Enter your second number: '))
if operation == '+':
print('{} + {} = '.format(number_1, number_2))
print(number_1 + number_2)
elif operation == '-':
print('{} - {} = '.format(number_1, number_2))
print(number_1 - number_2)
elif operation == '*':
print('{} * {} = '.format(number_1, number_2))
print(number_1 * number_2)
elif operation == '/':
print('{} / {} = '.format(number_1, number_2))
print(number_1 / number_2)
else:
print('You have not typed a valid operator, please run the program again.')
Итак, сначала программа предлагает пользователю ввести символ операции. Затем она запрашивает два числа. После этого она отображает пользовательский ввод и результат вычислений. Например, пользователь вводит *, затем 58 и 40.
Please type in the math operation you would like to complete:
+ for addition
- for subtraction
* for multiplication
/ for division
*
Please enter the first number: 58
Please enter the second number: 40
58 * 40 =
2320
Если же на первый запрос программы пользователь введёт символ %, он получит ошибку.
На данный момент программа выполняет все необходимые вычисления. Однако чтобы выполнить другую операцию, программу придётся перезапустить.
4: Определение функций
Чтобы программу не пришлось перезапускать после каждого обработанного примера, нужно определить несколько функций. Для начала поместим весь существующий код в функцию calculate() и добавим в программу ещё один слой. Чтобы программа запускалась, нужно добавить функцию в конец файла.
# Определение функции
def calculate():
operation = input('''
Please type in the math operation you would like to complete:
+ for addition
- for subtraction
* for multiplication
/ for division
''')
number_1 = int(input('Please enter the first number: '))
number_2 = int(input('Please enter the second number: '))
if operation == '+':
print('{} + {} = '.format(number_1, number_2))
print(number_1 + number_2)
elif operation == '-':
print('{} - {} = '.format(number_1, number_2))
print(number_1 - number_2)
elif operation == '*':
print('{} * {} = '.format(number_1, number_2))
print(number_1 * number_2)
elif operation == '/':
print('{} / {} = '.format(number_1, number_2))
print(number_1 / number_2)
else:
print('You have not typed a valid operator, please run the program again.')
# Вызов функции calculate() вне функции
calculate()
Создайте ещё одну функцию, состоящую из условных операторов. Этот блок кода позволит пользователю выбрать: продолжить работу с программой или завершить её. В данном случае операторов будет три: один if, один elif и один else для обработки ошибок.
Пусть функция называется again(). Добавьте её в конец блока def calculate():
...
# Определение функции again()
def again():
# Ввод пользователя
calc_again = input('''
Do you want to calculate again?
Please type Y for YES or N for NO.
''')
# Если пользователь вводит Y, программа запускает функцию calculate()
if calc_again == 'Y':
calculate()
# Если пользователь вводит N, программа попрощается и завершит работу
elif calc_again == 'N':
print('See you later.')
# Если пользователь вводит другой символ, программа снова запускает функцию again()
else:
again()
# Вызов calculate()
calculate()
Также можно устранить чувствительность к регистру: буквы y и n должны восприниматься так же, как Y и N. Для этого добавьте функцию строки str.upper():
...
def again():
calc_again = input('''
Do you want to calculate again?
Please type Y for YES or N for NO.
''')
# Accept 'y' or 'Y' by adding str.upper()
if calc_again.upper() == 'Y':
calculate()
# Accept 'n' or 'N' by adding str.upper()
elif calc_again.upper() == 'N':
print('See you later.')
else:
again()
...
Читайте также: Методы строк в Python 3
Теперь нужно добавить функцию again() в конец функции calculate(), чтобы программа запускала код, который спрашивает пользователя, хочет ли он продолжить работу.
def calculate():
operation = input('''
Please type in the math operation you would like to complete:
+ for addition
- for subtraction
* for multiplication
/ for division
''')
number_1 = int(input('Please enter the first number: '))
number_2 = int(input('Please enter the second number: '))
if operation == '+':
print('{} + {} = '.format(number_1, number_2))
print(number_1 + number_2)
elif operation == '-':
print('{} - {} = '.format(number_1, number_2))
print(number_1 - number_2)
elif operation == '*':
print('{} * {} = '.format(number_1, number_2))
print(number_1 * number_2)
elif operation == '/':
print('{} / {} = '.format(number_1, number_2))
print(number_1 / number_2)
else:
print('You have not typed a valid operator, please run the program again.')
# Добавление функции again() в calculate()
again()
def again():
calc_again = input('''
Do you want to calculate again?
Please type Y for YES or N for NO.
''')
if calc_again.upper() == 'Y':
calculate()
elif calc_again.upper() == 'N':
print('See you later.')
else:
again()
calculate()
Запустите программу в терминале с помощью команды:
python calculator.py
Теперь программу не нужно перезапускать.
5: Дополнительные действия
Написанная вами программа полностью готова к работе. Однако есть ещё много дополнений, которые при желании можно внести в код. Например, вы можете написать приветственное сообщение и добавить его в начало кода:
def welcome():
print('''
Welcome to Calculator
''')
...
# Затем нужно вызвать функции
welcome()
calculate()
Также можно добавить в программу больше функций для обработки ошибок. К примеру, программа должна продолжать работу даже если пользователь вводит слово вместо числа. На данный момент это не так: программа выдаст пользователю ошибку и прекратит работу.
Кроме того, если при выборе оператора деления (/) пользователь выбирает знаменатель 0, он должен получить ошибку:
ZeroDivisionError: division by zero
Для этого нужно написать исключение с помощью оператора try … except.
Программа ограничена 4 операторами, но вы можете расширить этот список:
...
operation = input('''
Please type in the math operation you would like to complete:
+ for addition
- for subtraction
* for multiplication
/ for division
** for power
% for modulo
''')
...
# Для возведения в степень и обработки модуля нужно добавить в код условные операторы.
Также в программу можно добавить операторы цикла.
Существует много способов для настройки обработки ошибок и улучшения каждого проекта. При этом всегда важно помнить, что не существует единственно правильного способа решить ту или иную проблему.
Заключение
Теперь вы знаете, как написать простейший калькулятор. После выполнения руководства вы можете самостоятельно добавить новые функции программы.
Tags: Python, Python 3
Многие программисты стараются изучать языки программирования с помощью написания достаточно простых программ. Один из вариантов – написание калькулятора. Конечно, можно посчитать в отладчике Python или запустив консоль. Но гораздо лучше написать на python свой калькулятор с графическим интерфейсом.
Считаем в консоле
Чтобы посчитать математические выражения можно запустить консоль. Запустить python. После этого набираем математические выражения и получаем ответ. Для этого даже не надо уметь программировать.
Делаем простой калькулятор
Лучше всего закреплять свои знания по программированию с помощью написания простых программ. Таких приложений можно придумать много – календарь, программа для хранения заметок, получение прогноза погоды.
Можно написать программу, которая делает скриншоты и сохраняет полученные изображения в папку. В любом случае, надо выбрать какое-нибудь не сложное задание, чтобы не закопаться в нем. Потом его можно будет расширить и сделать по-настоящему полезное приложение.
В нашем случае мы разберем, как создать простой графический калькулятор на Python 3. Для реализации графического интерфейса воспользуемся стандартным пакетом Tkinter. Он входит в состав Python 3. Соответственно, если у вас установлен Python, то дополнительно не надо ничего устанавливать.
В первых строках файла calculator.py подключаем библиотечные функции:
- Tkinter для графического интерфейса;
- Decimal для вычислений с большей точность, так как точности float не достаточно.
Импорт библиотек и исходные данные
Создаем окно приложения — объект Tk с заголовком Calculator. Во вложенном кортеже buttons будут храниться обозначения для кнопок. В список stack будем добавлять введенные числа и операции, которые надо совершить. activeStr предназначен для хранения набираемого числа.
from tkinter import *
from decimal import *
root = Tk()
root.title('Calculator')
buttons = (('7', '8', '9', '/', '4'),
('4', '5', '6', '*', '4'),
('1', '2', '3', '-', '4'),
('0', '.', '=', '+', '4')
)
activeStr = ''
stack = []
Вычисление результата
Функция calculate получает из списка stack операнды и операцию которую над ними надо произвести. Результат отображается в надписи label. Получать из списка строки будем с помощью метода pop.
def calculate():
global stack
global label
result = 0
operand2 = Decimal(stack.pop())
operation = stack.pop()
operand1 = Decimal(stack.pop())
if operation == '+':
result = operand1 + operand2
if operation == '-':
result = operand1 - operand2
if operation == '/':
result = operand1 / operand2
if operation == '*':
result = operand1 * operand2
label.configure(text=str(result))
Обработка нажатия
В функции click выполняется обработка нажатой клавиши. В качестве ее аргумента передается текст, отображаемый на кнопке, которую нажали. Хотелось бы хранить вводимое значение прямо в надписи, а не создавать для этого отдельную переменную. Но так не получается из-за алгоритма работы. После того как посчитан результат, он записывается в надписи. При попытке после этого начать вводить новое число, оно бы дописывало прежний результат.
В списке с операторами и командами для калькулятора не обязательно их будет 3. Но при обработке с помощью метода pop, будут рассматриваться 3 последних введенных значения. А после проведения расчета список очистится. Далее в него добавляется полученный результат, на случай если пользователь нажмет на калькуляторе клавишу операции сразу, а не будет вводить новое число.
def click(text):
global activeStr
global stack
if text == 'CE':
stack.clear()
activeStr = ''
label.configure(text='0')
elif '0' <= text <= '9':
activeStr += text
label.configure(text=activeStr)
elif text == '.':
if activeStr.find('.') == -1:
activeStr += text
label.configure(text=activeStr)
else:
if len(stack) >= 2:
stack.append(label['text'])
calculate()
stack.clear()
stack.append(label['text'])
activeStr = ''
if text != '=':
stack.append(text)
else:
if text != '=':
stack.append(label['text'])
stack.append(text)
activeStr = ''
label.configure(text='0')
Внешний вид
Теперь займемся оформлением внешнего вида калькулятора и зададим обработку нажатия кнопок. Создаем надпись для вывода набираемых значений и результатов. В цикле создаем кнопки. Расположение кнопок и надписи осуществляется в табличном виде с помощью упаковщика grid. И в завершении запускаем цикл обработки событий mainloop.
label = Label(root, text='0', width=35)
label.grid(row=0, column=0, columnspan=4, sticky="nsew")
button = Button(root, text='CE', command=lambda text='CE': click(text))
button.grid(row=1, column=3, sticky="nsew")
for row in range(4):
for col in range(4):
button = Button(root, text=buttons[row][col],
command=lambda row=row, col=col: click(buttons[row][col]))
button.grid(row=row + 2, column=col, sticky="nsew")
root.grid_rowconfigure(6, weight=1)
root.grid_columnconfigure(4, weight=1)
root.mainloop()
У надписи выставлена ширина 35, для того, чтобы оформление кнопок подстраивалось под надпись. И в результате кнопки при этом значении лучше выглядят.
Для того, чтобы кнопки правильно работали, пришлось для каждой из кнопок создать свою функцию с помощью lambda.
По аналогии приведенного кода python калькулятора можно сдель, допустим, календарь. Для этого надо будет запрашивать текущую дату у операционной системы. Открывать нужный месяц, рассчитывать какие числа выпадут на понедельники, какой год високосный. Сделать возможность менять год и месяцы.
from tkinter import *
import math
import tkinter.messagebox
root = Tk()
root.title("Scientific Calculator")
root.configure(background = 'white')
root.resizable(width=False, height=False)
root.geometry("480x568+450+90")
calc = Frame(root)
calc.grid()
class Calc():
def __init__(self):
self.total=0
self.current=''
self.input_value=True
self.check_sum=False
self.op=''
self.result=False
def numberEnter(self, num):
self.result=False
firstnum=txtDisplay.get()
secondnum=str(num)
if self.input_value:
self.current = secondnum
self.input_value=False
else:
if secondnum == '.':
if secondnum in firstnum:
return
self.current = firstnum+secondnum
self.display(self.current)
def sum_of_total(self):
self.result=True
self.current=float(self.current)
if self.check_sum==True:
self.valid_function()
else:
self.total=float(txtDisplay.get())
def display(self, value):
txtDisplay.delete(0, END)
txtDisplay.insert(0, value)
def valid_function(self):
if self.op == "add":
self.total += self.current
if self.op == "sub":
self.total -= self.current
if self.op == "multi":
self.total *= self.current
if self.op == "divide":
self.total /= self.current
if self.op == "mod":
self.total %= self.current
self.input_value=True
self.check_sum=False
self.display(self.total)
def operation(self, op):
self.current = float(self.current)
if self.check_sum:
self.valid_function()
elif not self.result:
self.total=self.current
self.input_value=True
self.check_sum=True
self.op=op
self.result=False
def Clear_Entry(self):
self.result = False
self.current = "0"
self.display(0)
self.input_value=True
def All_Clear_Entry(self):
self.Clear_Entry()
self.total=0
def pi(self):
self.result = False
self.current = math.pi
self.display(self.current)
def tau(self):
self.result = False
self.current = math.tau
self.display(self.current)
def e(self):
self.result = False
self.current = math.e
self.display(self.current)
def mathPM(self):
self.result = False
self.current = -(float(txtDisplay.get()))
self.display(self.current)
def squared(self):
self.result = False
self.current = math.sqrt(float(txtDisplay.get()))
self.display(self.current)
def cos(self):
self.result = False
self.current = math.cos(math.radians(float(txtDisplay.get())))
self.display(self.current)
def cosh(self):
self.result = False
self.current = math.cosh(math.radians(float(txtDisplay.get())))
self.display(self.current)
def tan(self):
self.result = False
self.current = math.tan(math.radians(float(txtDisplay.get())))
self.display(self.current)
def tanh(self):
self.result = False
self.current = math.tanh(math.radians(float(txtDisplay.get())))
self.display(self.current)
def sin(self):
self.result = False
self.current = math.sin(math.radians(float(txtDisplay.get())))
self.display(self.current)
def sinh(self):
self.result = False
self.current = math.sinh(math.radians(float(txtDisplay.get())))
self.display(self.current)
def log(self):
self.result = False
self.current = math.log(float(txtDisplay.get()))
self.display(self.current)
def exp(self):
self.result = False
self.current = math.exp(float(txtDisplay.get()))
self.display(self.current)
def acosh(self):
self.result = False
self.current = math.acosh(float(txtDisplay.get()))
self.display(self.current)
def asinh(self):
self.result = False
self.current = math.asinh(float(txtDisplay.get()))
self.display(self.current)
def expm1(self):
self.result = False
self.current = math.expm1(float(txtDisplay.get()))
self.display(self.current)
def lgamma(self):
self.result = False
self.current = math.lgamma(float(txtDisplay.get()))
self.display(self.current)
def degrees(self):
self.result = False
self.current = math.degrees(float(txtDisplay.get()))
self.display(self.current)
def log2(self):
self.result = False
self.current = math.log2(float(txtDisplay.get()))
self.display(self.current)
def log10(self):
self.result = False
self.current = math.log10(float(txtDisplay.get()))
self.display(self.current)
def log1p(self):
self.result = False
self.current = math.log1p(float(txtDisplay.get()))
self.display(self.current)
added_value = Calc()
txtDisplay = Entry(calc, font=('Helvetica',20,'bold'),
bg='black',fg='white',
bd=30,width=28,justify=RIGHT)
txtDisplay.grid(row=0,column=0, columnspan=4, pady=1)
txtDisplay.insert(0,"0")
numberpad = "789456123"
i=0
btn = []
for j in range(2,5):
for k in range(3):
btn.append(Button(calc, width=6, height=2,
bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,text=numberpad[i]))
btn[i].grid(row=j, column= k, pady = 1)
btn[i]["command"]=lambda x=numberpad[i]:added_value.numberEnter(x)
i+=1
btnClear = Button(calc, text=chr(67),width=6,
height=2,bg='powder blue',
font=('Helvetica',20,'bold')
,bd=4, command=added_value.Clear_Entry
).grid(row=1, column= 0, pady = 1)
btnAllClear = Button(calc, text=chr(67)+chr(69),
width=6, height=2,
bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,
command=added_value.All_Clear_Entry
).grid(row=1, column= 1, pady = 1)
btnsq = Button(calc, text="u221A",width=6, height=2,
bg='powder blue', font=('Helvetica',
20,'bold'),
bd=4,command=added_value.squared
).grid(row=1, column= 2, pady = 1)
btnAdd = Button(calc, text="+",width=6, height=2,
bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.operation("add")
).grid(row=1, column= 3, pady = 1)
btnSub = Button(calc, text="-",width=6,
height=2,bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.operation("sub")
).grid(row=2, column= 3, pady = 1)
btnMul = Button(calc, text="x",width=6,
height=2,bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.operation("multi")
).grid(row=3, column= 3, pady = 1)
btnDiv = Button(calc, text="/",width=6,
height=2,bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.operation("divide")
).grid(row=4, column= 3, pady = 1)
btnZero = Button(calc, text="0",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.numberEnter(0)
).grid(row=5, column= 0, pady = 1)
btnDot = Button(calc, text=".",width=6,
height=2,bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.numberEnter(".")
).grid(row=5, column= 1, pady = 1)
btnPM = Button(calc, text=chr(177),width=6,
height=2,bg='powder blue', font=('Helvetica',20,'bold'),
bd=4,command=added_value.mathPM
).grid(row=5, column= 2, pady = 1)
btnEquals = Button(calc, text="=",width=6,
height=2,bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.sum_of_total
).grid(row=5, column= 3, pady = 1)
btnPi = Button(calc, text="pi",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.pi
).grid(row=1, column= 4, pady = 1)
btnCos = Button(calc, text="Cos",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.cos
).grid(row=1, column= 5, pady = 1)
btntan = Button(calc, text="tan",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.tan
).grid(row=1, column= 6, pady = 1)
btnsin = Button(calc, text="sin",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.sin
).grid(row=1, column= 7, pady = 1)
btn2Pi = Button(calc, text="2pi",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.tau
).grid(row=2, column= 4, pady = 1)
btnCosh = Button(calc, text="Cosh",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.cosh
).grid(row=2, column= 5, pady = 1)
btntanh = Button(calc, text="tanh",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.tanh
).grid(row=2, column= 6, pady = 1)
btnsinh = Button(calc, text="sinh",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.sinh
).grid(row=2, column= 7, pady = 1)
btnlog = Button(calc, text="log",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.log
).grid(row=3, column= 4, pady = 1)
btnExp = Button(calc, text="exp",width=6, height=2,
bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.exp
).grid(row=3, column= 5, pady = 1)
btnMod = Button(calc, text="Mod",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.operation("mod")
).grid(row=3, column= 6, pady = 1)
btnE = Button(calc, text="e",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.e
).grid(row=3, column= 7, pady = 1)
btnlog10 = Button(calc, text="log10",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.log10
).grid(row=4, column= 4, pady = 1)
btncos = Button(calc, text="log1p",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.log1p
).grid(row=4, column= 5, pady = 1)
btnexpm1 = Button(calc, text="expm1",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd = 4,command=added_value.expm1
).grid(row=4, column= 6, pady = 1)
btngamma = Button(calc, text="gamma",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.lgamma
).grid(row=4, column= 7, pady = 1)
btnlog2 = Button(calc, text="log2",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.log2
).grid(row=5, column= 4, pady = 1)
btndeg = Button(calc, text="deg",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.degrees
).grid(row=5, column= 5, pady = 1)
btnacosh = Button(calc, text="acosh",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.acosh
).grid(row=5, column= 6, pady = 1)
btnasinh = Button(calc, text="asinh",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.asinh
).grid(row=5, column= 7, pady = 1)
lblDisplay = Label(calc, text = "Scientific Calculator",
font=('Helvetica',30,'bold'),
bg='black',fg='white',justify=CENTER)
lblDisplay.grid(row=0, column= 4,columnspan=4)
def iExit():
iExit = tkinter.messagebox.askyesno("Scientific Calculator",
"Do you want to exit ?")
if iExit>0:
root.destroy()
return
def Scientific():
root.resizable(width=False, height=False)
root.geometry("944x568+0+0")
def Standard():
root.resizable(width=False, height=False)
root.geometry("480x568+0+0")
menubar = Menu(calc)
filemenu = Menu(menubar, tearoff = 0)
menubar.add_cascade(label = 'File', menu = filemenu)
filemenu.add_command(label = "Standard", command = Standard)
filemenu.add_command(label = "Scientific", command = Scientific)
filemenu.add_separator()
filemenu.add_command(label = "Exit", command = iExit)
editmenu = Menu(menubar, tearoff = 0)
menubar.add_cascade(label = 'Edit', menu = editmenu)
editmenu.add_command(label = "Cut")
editmenu.add_command(label = "Copy")
editmenu.add_separator()
editmenu.add_command(label = "Paste")
root.config(menu=menubar)
root.mainloop()
from tkinter import *
import math
import tkinter.messagebox
root = Tk()
root.title("Scientific Calculator")
root.configure(background = 'white')
root.resizable(width=False, height=False)
root.geometry("480x568+450+90")
calc = Frame(root)
calc.grid()
class Calc():
def __init__(self):
self.total=0
self.current=''
self.input_value=True
self.check_sum=False
self.op=''
self.result=False
def numberEnter(self, num):
self.result=False
firstnum=txtDisplay.get()
secondnum=str(num)
if self.input_value:
self.current = secondnum
self.input_value=False
else:
if secondnum == '.':
if secondnum in firstnum:
return
self.current = firstnum+secondnum
self.display(self.current)
def sum_of_total(self):
self.result=True
self.current=float(self.current)
if self.check_sum==True:
self.valid_function()
else:
self.total=float(txtDisplay.get())
def display(self, value):
txtDisplay.delete(0, END)
txtDisplay.insert(0, value)
def valid_function(self):
if self.op == "add":
self.total += self.current
if self.op == "sub":
self.total -= self.current
if self.op == "multi":
self.total *= self.current
if self.op == "divide":
self.total /= self.current
if self.op == "mod":
self.total %= self.current
self.input_value=True
self.check_sum=False
self.display(self.total)
def operation(self, op):
self.current = float(self.current)
if self.check_sum:
self.valid_function()
elif not self.result:
self.total=self.current
self.input_value=True
self.check_sum=True
self.op=op
self.result=False
def Clear_Entry(self):
self.result = False
self.current = "0"
self.display(0)
self.input_value=True
def All_Clear_Entry(self):
self.Clear_Entry()
self.total=0
def pi(self):
self.result = False
self.current = math.pi
self.display(self.current)
def tau(self):
self.result = False
self.current = math.tau
self.display(self.current)
def e(self):
self.result = False
self.current = math.e
self.display(self.current)
def mathPM(self):
self.result = False
self.current = -(float(txtDisplay.get()))
self.display(self.current)
def squared(self):
self.result = False
self.current = math.sqrt(float(txtDisplay.get()))
self.display(self.current)
def cos(self):
self.result = False
self.current = math.cos(math.radians(float(txtDisplay.get())))
self.display(self.current)
def cosh(self):
self.result = False
self.current = math.cosh(math.radians(float(txtDisplay.get())))
self.display(self.current)
def tan(self):
self.result = False
self.current = math.tan(math.radians(float(txtDisplay.get())))
self.display(self.current)
def tanh(self):
self.result = False
self.current = math.tanh(math.radians(float(txtDisplay.get())))
self.display(self.current)
def sin(self):
self.result = False
self.current = math.sin(math.radians(float(txtDisplay.get())))
self.display(self.current)
def sinh(self):
self.result = False
self.current = math.sinh(math.radians(float(txtDisplay.get())))
self.display(self.current)
def log(self):
self.result = False
self.current = math.log(float(txtDisplay.get()))
self.display(self.current)
def exp(self):
self.result = False
self.current = math.exp(float(txtDisplay.get()))
self.display(self.current)
def acosh(self):
self.result = False
self.current = math.acosh(float(txtDisplay.get()))
self.display(self.current)
def asinh(self):
self.result = False
self.current = math.asinh(float(txtDisplay.get()))
self.display(self.current)
def expm1(self):
self.result = False
self.current = math.expm1(float(txtDisplay.get()))
self.display(self.current)
def lgamma(self):
self.result = False
self.current = math.lgamma(float(txtDisplay.get()))
self.display(self.current)
def degrees(self):
self.result = False
self.current = math.degrees(float(txtDisplay.get()))
self.display(self.current)
def log2(self):
self.result = False
self.current = math.log2(float(txtDisplay.get()))
self.display(self.current)
def log10(self):
self.result = False
self.current = math.log10(float(txtDisplay.get()))
self.display(self.current)
def log1p(self):
self.result = False
self.current = math.log1p(float(txtDisplay.get()))
self.display(self.current)
added_value = Calc()
txtDisplay = Entry(calc, font=('Helvetica',20,'bold'),
bg='black',fg='white',
bd=30,width=28,justify=RIGHT)
txtDisplay.grid(row=0,column=0, columnspan=4, pady=1)
txtDisplay.insert(0,"0")
numberpad = "789456123"
i=0
btn = []
for j in range(2,5):
for k in range(3):
btn.append(Button(calc, width=6, height=2,
bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,text=numberpad[i]))
btn[i].grid(row=j, column= k, pady = 1)
btn[i]["command"]=lambda x=numberpad[i]:added_value.numberEnter(x)
i+=1
btnClear = Button(calc, text=chr(67),width=6,
height=2,bg='powder blue',
font=('Helvetica',20,'bold')
,bd=4, command=added_value.Clear_Entry
).grid(row=1, column= 0, pady = 1)
btnAllClear = Button(calc, text=chr(67)+chr(69),
width=6, height=2,
bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,
command=added_value.All_Clear_Entry
).grid(row=1, column= 1, pady = 1)
btnsq = Button(calc, text="u221A",width=6, height=2,
bg='powder blue', font=('Helvetica',
20,'bold'),
bd=4,command=added_value.squared
).grid(row=1, column= 2, pady = 1)
btnAdd = Button(calc, text="+",width=6, height=2,
bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.operation("add")
).grid(row=1, column= 3, pady = 1)
btnSub = Button(calc, text="-",width=6,
height=2,bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.operation("sub")
).grid(row=2, column= 3, pady = 1)
btnMul = Button(calc, text="x",width=6,
height=2,bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.operation("multi")
).grid(row=3, column= 3, pady = 1)
btnDiv = Button(calc, text="/",width=6,
height=2,bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.operation("divide")
).grid(row=4, column= 3, pady = 1)
btnZero = Button(calc, text="0",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.numberEnter(0)
).grid(row=5, column= 0, pady = 1)
btnDot = Button(calc, text=".",width=6,
height=2,bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.numberEnter(".")
).grid(row=5, column= 1, pady = 1)
btnPM = Button(calc, text=chr(177),width=6,
height=2,bg='powder blue', font=('Helvetica',20,'bold'),
bd=4,command=added_value.mathPM
).grid(row=5, column= 2, pady = 1)
btnEquals = Button(calc, text="=",width=6,
height=2,bg='powder blue',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.sum_of_total
).grid(row=5, column= 3, pady = 1)
btnPi = Button(calc, text="pi",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.pi
).grid(row=1, column= 4, pady = 1)
btnCos = Button(calc, text="Cos",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.cos
).grid(row=1, column= 5, pady = 1)
btntan = Button(calc, text="tan",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.tan
).grid(row=1, column= 6, pady = 1)
btnsin = Button(calc, text="sin",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.sin
).grid(row=1, column= 7, pady = 1)
btn2Pi = Button(calc, text="2pi",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.tau
).grid(row=2, column= 4, pady = 1)
btnCosh = Button(calc, text="Cosh",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.cosh
).grid(row=2, column= 5, pady = 1)
btntanh = Button(calc, text="tanh",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.tanh
).grid(row=2, column= 6, pady = 1)
btnsinh = Button(calc, text="sinh",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.sinh
).grid(row=2, column= 7, pady = 1)
btnlog = Button(calc, text="log",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.log
).grid(row=3, column= 4, pady = 1)
btnExp = Button(calc, text="exp",width=6, height=2,
bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.exp
).grid(row=3, column= 5, pady = 1)
btnMod = Button(calc, text="Mod",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=lambda:added_value.operation("mod")
).grid(row=3, column= 6, pady = 1)
btnE = Button(calc, text="e",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.e
).grid(row=3, column= 7, pady = 1)
btnlog10 = Button(calc, text="log10",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.log10
).grid(row=4, column= 4, pady = 1)
btncos = Button(calc, text="log1p",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.log1p
).grid(row=4, column= 5, pady = 1)
btnexpm1 = Button(calc, text="expm1",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd = 4,command=added_value.expm1
).grid(row=4, column= 6, pady = 1)
btngamma = Button(calc, text="gamma",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.lgamma
).grid(row=4, column= 7, pady = 1)
btnlog2 = Button(calc, text="log2",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.log2
).grid(row=5, column= 4, pady = 1)
btndeg = Button(calc, text="deg",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.degrees
).grid(row=5, column= 5, pady = 1)
btnacosh = Button(calc, text="acosh",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.acosh
).grid(row=5, column= 6, pady = 1)
btnasinh = Button(calc, text="asinh",width=6,
height=2,bg='black',fg='white',
font=('Helvetica',20,'bold'),
bd=4,command=added_value.asinh
).grid(row=5, column= 7, pady = 1)
lblDisplay = Label(calc, text = "Scientific Calculator",
font=('Helvetica',30,'bold'),
bg='black',fg='white',justify=CENTER)
lblDisplay.grid(row=0, column= 4,columnspan=4)
def iExit():
iExit = tkinter.messagebox.askyesno("Scientific Calculator",
"Do you want to exit ?")
if iExit>0:
root.destroy()
return
def Scientific():
root.resizable(width=False, height=False)
root.geometry("944x568+0+0")
def Standard():
root.resizable(width=False, height=False)
root.geometry("480x568+0+0")
menubar = Menu(calc)
filemenu = Menu(menubar, tearoff = 0)
menubar.add_cascade(label = 'File', menu = filemenu)
filemenu.add_command(label = "Standard", command = Standard)
filemenu.add_command(label = "Scientific", command = Scientific)
filemenu.add_separator()
filemenu.add_command(label = "Exit", command = iExit)
editmenu = Menu(menubar, tearoff = 0)
menubar.add_cascade(label = 'Edit', menu = editmenu)
editmenu.add_command(label = "Cut")
editmenu.add_command(label = "Copy")
editmenu.add_separator()
editmenu.add_command(label = "Paste")
root.config(menu=menubar)
root.mainloop()
Для создания нашего калькулятора на Python мы будем использовать математические операторы, условные операторы, функции и обработку пользовательского ввода.
В системе должен быть установлен Python 3 на локальном компьютере и на нем должна быть настроена среда программирования.
Ввод от пользователя
Мы будем принимать ввод от пользователя. Для этой цели мы будем использовать функцию Python input(). В этой программе мы позволим пользователю вводить два числа, поэтому давайте запустим программу для запроса двух чисел.
num_1 = input('Enter your first number: ')
num_2 = input('Enter your second number: ')
Вывод:
Enter your first number: 10 Enter your second number: 5
Мы должны сохранить программу перед ее запуском. Вы должны иметь возможность вводить текст в окне терминала в ответ на каждое приглашение.
Определение и использование операторов
Теперь давайте добавим в нашу программу калькулятора такие операторы, как сложение, умножение, деление и вычитание.
num_1 = int(input('Enter your first number: '))
num_2 = int(input('Enter your second number: '))
# Addition
print('{} + {} = '.format(num_1, num_2))
print(num_1 + num_2)
# Subtraction
print('{} - {} = '.format(num_1, num_2))
print(num_1 - num_2)
# Multiplication
print('{} * {} = '.format(num_1, num_2))
print(num_1 * num_2)
# Division
print('{} / {} = '.format(num_1, num_2))
print(num_1 / num_2)
# The format() will help out output look descent and formatted.
Вывод:
Enter your first number: 15 Enter your second number: 10 15 + 10 = 25 15 - 10 = 05 15 * 10 = 150 15 / 10 = 1.5
Если вы посмотрите на вышеприведенный вывод, мы можем заметить, что как только пользователь вводит num_1 как 15 и num_2 как 10 , все операции калькулятора выполняются.
Если мы хотим ограничить программу выполнением только одной операции за раз, нам придется использовать условные операторы и сделать всю программу операций на основе выбора пользователя.
Итак, мы начнем с добавления некоторой информации в верхней части программы вместе с выбором, который нужно сделать, чтобы пользователь понял, что он должен выбрать.
choice = input('''
Please select the type of operation you want to perform:
+ for addition
- for subtraction
* for multiplication
/ for division
''')
num_1 = int(input('Enter your first number: '))
num_2 = int(input('Enter your second number: '))
if choice == '+':
print('{} + {} = '.format(num_1, num_2))
print(num_1 + num_2)
elif choice == '-':
print('{} - {} = '.format(num_1, num_2))
print(num_1 - num_2)
elif choice == '*':
print('{} * {} = '.format(num_1, num_2))
print(num_1 * num_2)
elif choice == '/':
print('{} / {} = '.format(num_1, num_2))
print(num_1 / num_2)
else:
print('Enter a valid operator, please run the program again.')
Вывод:
Please select the type of operation you want to perform: + for addition - for subtraction * for multiplication / for division * Please enter the first number: 10 Please enter the second number: 40 10 * 40 = 400