Как сделать калькулятор в python

Программа «Простейший калькулятор»

Написать программу, которая выполняет над двумя вещественными числами одну из четырех арифметических операций (сложение, вычитание, умножение или деление). Программа должна завершаться только по желанию пользователя.

Решение задачи на языке программирования Python

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

Если пользователь ввел знак, который не является ни знаком арифметической операции, ни символом-«прерывателем» работы программы, то вывести сообщение о некорректном вводе.

Если был введен один из четырех знаков операции, запросить ввод двух чисел.

В зависимости от знака операции выполнить соответствующее арифметическое действие.

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

print("0 в качестве знака операции" "\nзавершит работу программы\n") while True: s = input("Знак (+, -, *, /): ") if s == '0': break if s in ('+', '-', '*', '/'): a = float(input("a = ")) b = float(input("b = ")) if s == '+': print("%.2f" % (a + b)) elif s == '-': print("%.2f" % (a - b)) elif s == '*': print("%.2f" % (a * b)) elif s == '/': if b != 0: print("%.2f" % (a / b)) else: print("Деление на ноль!") else: print("Неверный знак операции!")

Пример выполнения программы:

0 в качестве знака операции завершит работу программы Знак (+, -, *, /): / a = -9.34 b = 3.215 -2.91 Знак (+, -, *, /): & Неверный знак операции! Знак (+, -, *, /): - a = 4005 b = 1358 2647.00 Знак (+, -, *, /): 0

Вариант решение задачи с помощью оператора match (появился в Python 3.10):

print("0 в качестве знака - выход из программы\n") while True: s = input("Знак (+, -, *, /): ") if s in ('+', '-', '*', '/'): a = float(input("a = ")) b = float(input("b = ")) match s: case '+': print("%.2f" % (a + b)) case '-': print("%.2f" % (a - b)) case '*': print("%.2f" % (a * b)) case '/': if b != 0: print("%.2f" % (a / b)) else: print("Деление на ноль!") case '0': break case _: print("Неверный знак операции!")

X Скрыть Наверх

Решение задач на Python

Калькулятор на python

Здравствуйте, в предыдущей статье я показывал как сделать игру на 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() 

Простой калькулятор на Python

Python — это популярный и многофункциональный язык программирования с простым синтаксисом, который подходит для новичков. Его используют в разных сферах от машинного обучения до создания Телеграм-ботов. В этой статье мы рассмотрим процесс написания кода простого калькулятора на Python шаг за шагом.

Функции калькулятора

Созданный калькулятор будет иметь все базовые арифметические функции:

Также в калькуляторе будут предусмотрены расширенные функции:

• расчет процента от числа;
• возведение числа в степень;
• логарифм числа.

Например, программа сможет выполнять такие вычисления:

Определив функции программы, можно приступать к написанию кода.

Отображение результата в коде

Для отображения текста и результатов мы будем использовать функцию print().

В качестве примера можно написать в консоли произвольный текст:

print ('Создаем калькулятор на Python!')

Результат:

Создаем калькулятор на Python!

print 795

Результат:

Комьюнити теперь в Телеграм
Подпишитесь и будьте в курсе последних IT-новостей

Работа с переменными

Аналогично предыдущему примеру, рассмотрим сценарий с сохранением результата в переменную.

Это позволит проводить вычисления:

result = 7 * 6 print(result)

Результат:

Обработка ввода данных

Перейдем к работе с пользовательским вводом. Обработка ввода в Python осуществляется функцией input(), которая позволяет написать строку-подсказку для пользователя. Она учитывает введенную информацию до нажатия клавиши Enter.

Рассмотрим на примере имени и фамилии два результата — без ввода строки и с ним.

name = input() #Иван surname = input() #Петров print('Ваше имя и фамилия:') print(name) print(surname)

Результат:

Иван
Петров
Ваше имя и фамилия:
Иван
Петров

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

На практике пример с вводом выглядит следующим образом:

name = input('Укажите имя: ') #Иван surname = input('Укажите фамилию: ') #Петров print('Ваше имя и фамилия: ') print(name) print(surname)

Результат:

Укажите имя: Иван
Укажите фамилию: Петров
Ваше имя и фамилия:
Иван
Петров

По умолчанию каждый вызов print() разделяет текст переходом на новую строку. Это можно изменить, используя параметр end с аргументом «пробел»:

name = input('Укажите имя: ') #Иван surname = input('Укажите фамилию: ') #Петров print('Ваше имя и фамилия: ', end = ' ') print(name, end = ' ') print(surname)

В результате имя и фамилия будут отображены в одной строке:

Укажите имя: Иван
Укажите фамилию: Петров
Ваше имя и фамилия: Иван Петров

Вместо множественных вызовов print() можно эффективно управлять выводом текста с помощью методов объединения и форматирования строк.

Методы объединения и форматирования строк

Объединение (конкатенация) строк позволяет сделать код более чистым. При этом нужно не забывать добавлять пробел между именем и фамилией для читаемости.

name = input('Укажите имя: ') #Федор surname = input('Укажите фамилию: ') #Смирнов print('Ваше имя и фамилия: ' + name + ' ' + surname)

Результат:

Укажите имя: Федор
Укажите фамилию: Смирнов
Ваше имя и фамилия: Федор Смирнов

Аналогичный результат можно получить путем форматирования строк с использованием f-строк в Python. В этом случае переменные заключаются в фигурные скобки и вставляются прямо в строку, а перед ней ставится символ ‘f’.

name = input('Укажите имя: ') #Федор surname = input('Укажите фамилию: ') #Смирнов print(f'Ваше имя и фамилия: ')

Результат:

Укажите имя: Федор
Укажите фамилию: Смирнов
Ваше имя и фамилия: Федор Смирнов

Конвертация строк в числа

При использовании функции input() вводимые данные по умолчанию считываются как строки. Это может привести к неожиданным результатам при выполнении арифметических операций.

first = input('Укажите первое число: ') #70 second = input('Укажите второе число: ') #300 summ = first + second print(f'Сумма чисел: ')

Результат:

Укажите первое число: 70
Укажите второе число: 300
70300

Здесь произошла конкатенация (объединение) строк, а не сложение чисел. Чтобы калькулятор корректно выполнял сложение, строки нужно преобразовать в числа с помощью функции int().

first = int(input('Укажите первое число: ')) #70 second = int(input('Укажите второе число: ')) #300 summ = first + second print(f'Сумма чисел: ')

Результат:

Укажите первое число: 70
Укажите второе число: 300
Сумма чисел: 370

Работа с ошибками

При вводе данных, которые не могут быть преобразованы в целое число, программа выдаст ошибку. Например, если вместо числа вставить буквы.

first = int(input('Укажите первое число: ')) #abc

Результат:

Укажите первое число: abc
ValueError: invalid literal for int() with base 10: ‘abc’

Это связано с тем, что функция int() не может преобразовать произвольный текст в число. Чтобы избежать таких ситуаций, целесообразно организовать механизм повторного ввода, пока пользователь не внесет корректные данные. Детально разберем этот аспект ниже, при обсуждении циклов.

Функциональная архитектура калькулятора

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

Сначала определим функции для базовых арифметических операций калькулятора:

Каждая функция примет два аргумента: first и second.

def summa(first, second): return first + second 

def sub(first, second): return first - second 

def mult(first, second): return first * second

def div(first, second): return first / second

После определения функций проверим их работу:

num1 = int(input('Введите первое число: ')) num2 = int(input('Введите второе число: ')) print(f'Сумма двух чисел: , разность: , ' f'умножение: , частное: ')

Результат:

Введите первое число: 10
Введите второе число: 5
Сумма двух чисел: 15, разность: 5, умножение: 50, частное: 2.0

Таким образом, каждая функция выполняет свою задачу, и можно их комбинировать для решения более сложных задач.

Управление потоком выполнения: if-операторы

Условные операторы (if-операторы) в Python позволяют управлять потоком выполнения программы.

Основной оператор if работает по простому принципу:

if условие_верно: # Выполняется данный блок кода

Простое сравнение чисел:

num1 = int(input('Введите первое число: ')) num2 = int(input('Введите второе число: ')) if num1 == num2: print('Одинаковые числа')

Результат:

Введите первое число: 9
Введите второе число: 9
Одинаковые числа

Если написать разные числа, то не будет никакого результата, так как нет инструкций для этого случая:

Введите первое число: 9
Введите второе число: 7

Для выполнения разных блоков кода в зависимости от условия используется конструкция if-else:

if условие_верно: # Выполняется данный блок кода else: # Выполняется данный блок кода 

Чтобы перебрать несколько инструкций, можно использовать ветвь if-elif-else:

if условие_1: # Блок кода 1 elif условие_2: # Блок кода 2 # . else: # Блок кода n

Пример с if-else — сравнение чисел:

num1 = int(input('Введите первое число: ')) num2 = int(input('Введите второе число: ')) if num1 == num2: print('Одинаковые числа') else: print('Числа разные')

Результат:

Введите первое число: 10
Введите второе число: 20
Числа разные

Пример выбора операции:

oper = input('Выберите операцию (Введите +, -, * или /): ') if oper == '+': print('Вы выбрали сумму') elif oper == '-': print('Вы выбрали разность') elif oper == '*': print('Вы выбрали умножение') elif oper == '/': print('Вы выбрали деление') else: print('Некорректная операция!')

Результат:

Выберите операцию (Введите +, -, * или /): *
Вы выбрали умножение
Выберите операцию (Введите +, -, * или /): Y
Некорректная операция!

Таким образом, можно управлять потоком выполнения программы, предлагая пользователю выбор операций и обрабатывая их соответствующим образом.

Сборка функций в одну программу calculator

Для оптимизации кода и его легкой поддержки создадим три основные функции:

• operation() для запроса операции от пользователя;
• calc() для выполнения математических операций;
• run() — главная функция, вызывающая остальные и управляющая ходом программы.

Функции operation() и calc():

def operation(): mes = input('Выберите операцию (Введите +, -, * или /): ') if mes == '+': print('Вы выбрали сумму') elif mes == '-': print('Вы выбрали разность') elif mes == '*': print('Вы выбрали умножение') elif mes == '/': print('Вы выбрали деление') return mes def calc(first, second, oper): result = None if oper == '+': result = summa(first, second) elif oper == '-': result = sub(first, second) elif oper == '*': result = mult(first, second) elif oper == '/': result = div(first, second) else: print('Некорректная операция!') return result 

В функции operation() пользователь выбирает операцию, которая затем возвращается. В calc() мы используем словарь для упрощения выбора операции и выполнения соответствующей математической функции.

def run(): first = int(input('Введите первое число: ')) second = int(input('Введите второе число: ')) oper = operation() result = calc(first, second, oper) print(f'Результат: ')

Эта функция интегрирует все предыдущие:

• запрашивает числа;
• вызывает operation() для выбора операции;
• вызывает calc() для вычисления результата, который затем выводится.

Чтобы запустить программу, нужно вызвать функцию run().

Результаты работы:

Введите первое число: 7
Введите второе число: 10
Выберите операцию (Введите +, -, * или /): +
Вы выбрали сумму
Результат: 17
Введите первое число: 7
Введите второе число: 10
Выберите операцию (Введите +, -, * или /): *
Вы выбрали умножение
Результат: 70
Введите первое число: 7
Введите второе число: 10
Выберите операцию (Введите +, -, * или /): er
Некорректная операция!
Результат: None

Расширение функционала калькулятора

Чтобы улучшить калькулятор, можно добавить в него больше функций.
Например:

• процент;
• возведение в степень;
• вычисление логарифма (потребуется импортировать библиотеку math).

Обновим функцию calc() следующим образом:

import math def calc(first, second, oper): result = None if oper == '+': result = first + second elif oper == '-': result = first - second elif oper == '*': result = first * second elif oper == '/': result = first / second elif oper == '%': result = (first / second) * 100 elif oper == '**': result = first ** second elif oper == 'log': result = math.log(first, second) else: print('Неизвестная операция!') return result

Теперь обновим функцию operation():

def operation(): mes = input('''Выберите операцию (Введите +, -, *, /, %, **, log): + - Сложение - - Вычитание * - Умножение / - Деление % - Процент первого числа от второго ** - Возведение в степень log - Логарифм первого числа по основанию второго\n''') if mes == '+': print('Вы выбрали сложение') elif mes == '-': print('Вы выбрали вычитание') elif mes == '*': print('Вы выбрали умножение') elif mes == '/': print('Вы выбрали деление') elif mes == '%': print('Вы выбрали нахождение процента первого числа от второго') elif mes == '**': print('Вы выбрали возведение в степень') elif mes == 'log': print('Вы выбрали логарифм') else: print('Неизвестная операция!') return mes

Теперь в калькуляторе доступен более широкий набор операций, и пользователь четко понимает, что делает каждая из них, благодаря информативному вводу.

Для иллюстрации рассмотрим пример вычисления 30% от 100.

Введите первое число: 30
Введите второе число: 100
Выберите операцию (Введите +, -, *, /, %, **, log):
+ — сложение двух чисел
— — вычитание двух чисел
* — произведение двух чисел
/ — деление двух чисел
% — процент первого числа от второго
** — возведение первого числа в степень второго
log — логарифм первого числа по основанию второго
%
Вы выбрали процент
Результ: 30

Обработка исключений и улучшение кода

Чтобы сделать калькулятор более надежным и удобным, нужно доработать четыре задачи:

• ошибку «деление на ноль»;
• ввод нечисловых данных;
• некорректный ввод символа операции;
• работа программы calculator после завершения (по желанию пользователя).

Чтобы решить проблему с делением на ноль, нужно модифицировать функцию calc() следующим образом:

if (second == 0): print('Деление на ноль запрещено!') return

Теперь, если пользователь попытается разделить на ноль, программа выдаст предупреждение и прекратит выполнение операции.

Для обработки ошибок ввода и некорректных символов операции будем использовать циклы и исключения.

Использование циклов и обработка исключений

Чтобы сделать программу более устойчивой к ошибкам и удобной для пользователя, применим циклы и механизмы обработки исключений.

Для начала нужно написать список всех допустимых операций:

correct_operations = ['+', '-', '*', '/', '%', '**', 'log']

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

while mes not in correct_operations: print('Такой операции нет в списке. Попробуйте ещё!') mes = input()

Для обработки ситуаций, когда введены не целые числа, добавим в функцию run() блок try-except:

try: first = int(input('Укажите первое число: ')) except ValueError: first = int(input('Вы ввели некорректные данные. Пожалуйста, введите целое число.')) try: second = int(input('Укажите второе число: ')) except ValueError: second = int(input('Вы ввели некорректные данные. Пожалуйста, введите целое число.'))

Для возможности продолжения работы с калькулятором после завершения одной операции, добавим следующий код:

progam_is_running = True while(progam_is_running): run() answer = input('Желаете продолжить?\n' ' Введите + если да и прочий символ, если нет: ') if answer != '+': progam_is_running = False 

Таким образом, программа будет работать в цикле до тех пор, пока пользователь не решит завершить ее работу.

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

import math def summa (first, second): return first + second def sub (first, second): return first - second def mult (first, second): return first * second def div (first, second): return first / second def calc(first, second, oper): result = None if oper == '+': result = summa(first, second) elif oper == '-': result = sub(first, second) elif oper == '*': result = mult(first, second) elif oper == '/': if (second == 0): print('Деление на ноль запрещено!') return result = div(first, second) elif oper == '%': result = first / second * 100 elif oper == '**': result = first ** second elif oper == 'log': result = math.log(first, second) else: print('Некорректная операция!') return result def operation(): mes = input('Выберите операцию (Введите +, -, *, /, %, **, log):\n ' '+ - сложение двух чисел\n' '- - вычитание двух чисел\n' '* - умножение двух чисел\n' '/ - деление двух чисел\n' '% - процент первого числа от второго\n' '** - возведение первого числа в степень второго\n' 'log - логарифм первого числа по основанию второго\n') if mes == '+': print('Вы выбрали сумму') elif mes == '-': print('Вы выбрали разность') elif mes == '*': print('Вы выбрали умножение') elif mes == '/': print('Вы выбрали деление') elif mes == '%': print('Вы выбрали нахождение процента первого числа от второго') elif mes == '**': print('Вы выбрали возведение в степень') elif mes == 'log': print('Вы выбрали логарифм') correct_operations = ['+', '-', '*', '/', '%', '**', 'log'] while mes not in correct_operations: print('Такой операции нет в списке. Попробуйте ещё!') mes = input() return mes def run(): try: first = int(input('Укажите первое число: ')) except ValueError: first = int(input('Вы ввели некорректные данные. Пожалуйста, введите целое число.')) try: second = int(input('Укажите второе число: ')) except ValueError: second = int(input('Вы ввели некорректные данные. Пожалуйста, введите целое число.')) op = operation() result = calc(first, second, op) print(f'Результат: ') progam_is_running = True while(progam_is_running): run() answer = input('Желаете продолжить?\n' ' Введите + если да и прочий символ, если нет: ') if answer != '+': progam_is_running = False

Заключение

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

Как сделать калькулятор в python

Позиционирование окна в центре экрана

Чтобы разместить окно Tkinter приложения в центре экрана, необходимо:

• Воспользоваться методами winfo_screenwidth() и winfo_screenheight() для получения ширины и высоты экрана соответственно.
• Передать в метод geometry() координаты x и y, равные половине ширины и высоты экрана за минусом половины ширины и высоты окна приложения.

Код будет выглядеть так:

Размещение элементов интерфейса в Tkinter

Элементы интерфейса в Tkinter называются виджетами. Существует три основных способа расположения виджетов на поверхности окна: pack(), place() и grid(). Каждый из этих методов имеет свои преимущества и недостатки, и выбор оптимального способа зависит от конкретной ситуации.

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

place() – позволяет задать точное положение и размер каждого виджета в окне. Его используют, когда необходимо точно расположить виджеты или создать перекрывающиеся элементы интерфейса. Недостаток – при изменении размеров окна или содержимого виджетов трудно сохранить расположение элементов.

grid() – упорядочивает виджеты в сетку из рядов и столбцов. Самый гибкий и мощный, позволяет создавать сложные интерфейсы, состоящие из виджетов разных размеров. Сложнее в использовании, чем pack(), поскольку требует больше кода для компоновки виджетов.

В целом, pack() хорошо подходит для простых интерфейсов, place() – для более сложных, а grid() используют для создания сложных интерфейсов, которым нужна адаптивность, особое позиционирование или растягивание виджетов на несколько строк / столбцов.

Связывание виджетов с функциями

Чтобы при нажатии кнопки выполнялось какое-то действие, нужно связать кнопку с определенной функцией. Чаще всего для этого используются методы command () и bind (), но при необходимости к виджетам Tkinter можно привязывать выполнение анонимных и частично примененных функций. Проиллюстрируем примерами.

Метод command () используется для прямого связывания функции с нажатием кнопки:

Метод bind(), по сравнению с command(), отличается большей гибкостью: его можно использовать для связывания функции с любым событием, происходящим в виджете – с нажатием кнопки, движением мыши, нажатием клавиши, изменением размера окна и так далее:

Назначение кнопке анонимной функции:

Связывание кнопки с частично примененной функцией:

Практика

Задание 1

Создайте Tkinter интерфейс для программы, которая получает от пользователя текст с помощью виджетов Entry и Button , а затем выводит полученную строку в терминале.

Ожидаемый результат:

import tkinter as tk from tkinter import ttk from math import sqrt class Calculator: def __init__(self, master): self.master = master self.master.title("Калькулятор") self.master.geometry("380x140") self.number_entry = ttk.Entry(self.master, width=20) self.number_entry.grid(row=0, column=0, columnspan=5, padx=5, pady=5) self.button_1 = ttk.Button(self.master, text="1", command=lambda: self.button_click(1)) self.button_2 = ttk.Button(self.master, text="2", command=lambda: self.button_click(2)) self.button_3 = ttk.Button(self.master, text="3", command=lambda: self.button_click(3)) self.button_4 = ttk.Button(self.master, text="4", command=lambda: self.button_click(4)) self.button_5 = ttk.Button(self.master, text="5", command=lambda: self.button_click(5)) self.button_6 = ttk.Button(self.master, text="6", command=lambda: self.button_click(6)) self.button_7 = ttk.Button(self.master, text="7", command=lambda: self.button_click(7)) self.button_8 = ttk.Button(self.master, text="8", command=lambda: self.button_click(8)) self.button_9 = ttk.Button(self.master, text="9", command=lambda: self.button_click(9)) self.button_0 = ttk.Button(self.master, text="0", command=lambda: self.button_click(0)) self.button_clear = ttk.Button(self.master, text="C", command=self.button_clear) self.button_add = ttk.Button(self.master, text="+", command=self.button_add) self.button_equal = ttk.Button(self.master, text="=", command=self.button_equal) self.button_subtract = ttk.Button(self.master, text="-", command=self.button_subtract) self.button_multiply = ttk.Button(self.master, text="*", command=self.button_multiply) self.button_divide = ttk.Button(self.master, text="/", command=self.button_divide) self.button_floor_div = ttk.Button(self.master, text="//", command=self.button_floor_div) self.button_modulus = ttk.Button(self.master, text="%", command=self.button_modulus) self.button_sqrt = ttk.Button(self.master, text="√", command=self.button_sqrt) self.button_neg = ttk.Button(self.master, text="+/-", command=self.button_neg) self.button_1.grid(row=1, column=0) self.button_2.grid(row=1, column=1) self.button_3.grid(row=1, column=2) self.button_add.grid(row=1, column=3) self.button_floor_div.grid(row=1, column=4) self.button_4.grid(row=2, column=0) self.button_5.grid(row=2, column=1) self.button_6.grid(row=2, column=2) self.button_subtract.grid(row=2, column=3) self.button_modulus.grid(row=2, column=4) self.button_7.grid(row=3, column=0) self.button_8.grid(row=3, column=1) self.button_9.grid(row=3, column=2) self.button_multiply.grid(row=3, column=3) self.button_sqrt.grid(row=3, column=4) self.button_clear.grid(row=4, column=0) self.button_0.grid(row=4, column=1) self.button_equal.grid(row=4, column=2) self.button_divide.grid(row=4, column=3) self.button_neg.grid(row=4, column=4) self.f_num = 0 self.math = "" def button_click(self, number): current = self.number_entry.get() self.number_entry.delete(0, tk.END) self.number_entry.insert(0, str(current) + str(number)) def button_clear(self): self.number_entry.delete(0, tk.END) def button_add(self): first_number = self.number_entry.get() self.math = "addition" self.f_num = int(first_number) self.number_entry.delete(0, tk.END) def button_equal(self): second_number = self.number_entry.get() self.number_entry.delete(0, tk.END) if self.math == "addition": self.number_entry.insert(0, self.f_num + int(second_number)) if self.math == "multiplication": self.number_entry.insert(0, self.f_num * int(second_number)) if self.math == "division": self.number_entry.insert(0, self.f_num / int(second_number)) if self.math == "floor_div": self.number_entry.insert(0, self.f_num // int(second_number)) if self.math == "modulus": self.number_entry.insert(0, self.f_num % int(second_number)) def button_subtract(self): first_number = self.number_entry.get() self.math = "subtraction" self.f_num = int(first_number) self.number_entry.delete(0, tk.END) def button_multiply(self): first_number = self.number_entry.get() self.math = "multiplication" self.f_num = int(first_number) self.number_entry.delete(0, tk.END) def button_divide(self): first_number = self.number_entry.get() self.math = "division" self.f_num = int(first_number) self.number_entry.delete(0, tk.END) def button_floor_div(self): first_number = self.number_entry.get() self.math = "floor_div" self.f_num = int(first_number) self.number_entry.delete(0, tk.END) def button_modulus(self): first_number = self.number_entry.get() self.math = "modulus" self.f_num = int(first_number) self.number_entry.delete(0, tk.END) def button_sqrt(self): number = float(self.number_entry.get()) result = sqrt(number) if result.is_integer(): self.number_entry.delete(0, tk.END) self.number_entry.insert(0, int(result)) else: self.number_entry.delete(0, tk.END) self.number_entry.insert(0, result) def button_neg(self): current = self.number_entry.get() if current.startswith("-"): current = current[1:] else: current = "-" + current self.number_entry.delete(0, tk.END) self.number_entry.insert(0, current) if __name__ == '__main__': root = tk.Tk() calc = Calculator(root) root.mainloop() 

Подведем итоги

В этой статье мы рассмотрели основы создания GUI для Python -программ и научились использовать основные виджеты Tkinter . В следующей главе будем изучать основы разработки игр с Pygame .

1. Особенности, сферы применения, установка, онлайн IDE
2. Все, что нужно для изучения Python с нуля – книги, сайты, каналы и курсы
3. Типы данных: преобразование и базовые операции
4. Методы работы со строками
5. Методы работы со списками и списковыми включениями
6. Методы работы со словарями и генераторами словарей
7. Методы работы с кортежами
8. Методы работы со множествами
9. Особенности цикла for
10. Условный цикл while
11. Функции с позиционными и именованными аргументами
12. Анонимные функции
13. Рекурсивные функции
14. Функции высшего порядка, замыкания и декораторы
15. Методы работы с файлами и файловой системой
16. Регулярные выражения
17. Основы скрапинга и парсинга
18. Основы ООП: инкапсуляция и наследование
19. Основы ООП: абстракция и полиморфизм
20. Графический интерфейс на Tkinter
21. Основы разработки игр на Pygame
22. Основы работы с SQLite
23. Основы веб-разработки на Flask
24. Основы работы с NumPy
25. Основы анализа данных с Pandas