tkinterでシンプル電卓を作る（evalを使わない計算ロジック）

1. このページで作るもの

電卓はGUI入門の定番です。理由は、小さいのに要素が全部そろっているからです。ボタンをきれいに並べる配置の話、押されたことを受け取るイベントの話、入力された文字を計算に変える処理の話、そして計算に失敗したときの後始末の話。この4つを一度に練習できるアプリは、ほかにあまりありません。

完成する画面が次の4枚です。ウィンドウのサイズは280×380ピクセル、ボタンは全部で19個です。4枚目は同じコードを Linux Mint 22.3 で実行した画面です。

読み終わったとき、あなたは次の3つができるようになります。

1. 19個のボタンをgrid()で狙った位置に並べられる
2. 「押した文字を式にする処理」と「式を計算する処理」を分けて書ける
3. ユーザーが入力した文字列を、そのまま実行せずに安全に計算できる

3つ目が、このページのいちばんの中身です。電卓の作り方を調べると、計算部分に eval() という組み込み関数を使う例が多く見つかります。手軽ですが、公式ドキュメントがはっきり警告している関数でもあります。このページでは、まず動く電卓を作り、そのうえで eval() を使わない書き方に置き換えます。

このページで扱う機能

• 数字と小数点の入力（先頭のゼロや小数点の重複を防ぐ）
• 四則演算（足す・引く・かける・割る）と優先順位
• パーセント計算・1文字削除・全消し
• キーボードからの入力
• ゼロ除算や未完成の式のエラー処理
• 19個のボタンをリストとループでまとめて生成

tkinterでウィンドウを出すところがまだ不安な方は、先にtkinterで最初のウィンドウを表示するを読んでおくと、この先の話がつながります。

2. 電卓を3つの部品に分けて考える

いきなりコードを書き始めると、ボタンの処理と計算の処理が混ざって手が止まります。電卓は、次の3つの部品に分けて考えると迷いません。

電卓の状態は、たったひとつの文字列で表せます。self.expression という変数に、押された順で "365*24*60*60" のように文字がたまっていくだけです。= が押されたら、その文字列を数値に変えて、結果でまた置き換えます。

関数の書き方そのものに不安があれば、関数の使い方とPythonの基本構文もあわせてどうぞ。

3. ボタンをgrid()で並べる（4列6行）

tkinterには配置の方法が3つあります。公式ドキュメントは grid について「ウィジェットを行と列の2次元の表に並べる。もっとも柔軟なマネージャで、まず選ぶべきもの」と説明しています。電卓のように格子状に並ぶ画面は、まさに grid の得意分野です。

まず、完成形の座標を先に決めてしまいます。次の図が、画面と grid(row=, column=) の対応です。

数えると、ボタンは19個、使うセルは20個、格子は4列6行です。ボタン19個に対してセルが1つ多いのは、0のボタンだけが2列分の幅を占めるからです。

19個のボタンをリストで定義する

ボタンを1個ずつ tk.Button(...) と書くと、19回同じような行が並びます。そこで、ボタンの情報だけをリストにまとめ、ループで生成します。1つのタプルが1つのボタンで、中身は（テキスト, 行, 列, columnspan, 背景色）です。

BUTTONS = [
    ("C",   1, 0, 1, "#e74c3c"), ("←",  1, 1, 1, "#e67e22"),
    ("%",   1, 2, 1, "#95a5a6"), ("÷",  1, 3, 1, "#3498db"),
    ("7",   2, 0, 1, "#ecf0f1"), ("8",   2, 1, 1, "#ecf0f1"),
    # …（中略。全19個は4章のコードを参照）
    ("0",   5, 0, 2, "#ecf0f1"), (".",   5, 2, 1, "#ecf0f1"),
    ("=",   5, 3, 1, "#2ecc71"),
]

この形にしておくと、ボタンを増やしたいときはリストに1行足すだけで済みます。位置を変えたいときも、数字を書き換えるだけです。「見た目のデータ」と「作る処理」を分けるという考え方は、この先どのGUIアプリでも効いてきます。

ループで生成し、grid()で置く

for (text, row, col, span, color) in self.BUTTONS:
    btn = tk.Button(
        self.root,
        text=text,
        bg=color,
        command=lambda t=text: self.on_press(t)   # ← t=text がポイント
    )
    btn.grid(
        row=row, column=col, columnspan=span,
        sticky="nsew", padx=2, pady=2
    )

grid()に渡しているオプションの意味は、それぞれ次のとおりです。

ウィンドウを広げたときに一緒に伸ばす

sticky だけでは、ウィンドウが大きくなったときにボタンは付いてきません。行と列に「余った空間を受け取る権利」を与える必要があります。

for i in range(4):
    self.root.columnconfigure(i, weight=1)   # 4つの列
for i in range(6):
    self.root.rowconfigure(i, weight=1)      # 6つの行

ここで筆者がつまずいた点を1つ。weight=1 は「余った分を均等に配る」指定であって、「列の幅を等しくする」指定ではありません。実際に組み立てて各ボタンの幅を測ると、次のようにばらつきました。

幅の基準になるのは、その列に入っているウィジェットが必要とする大きさです。「←」と「%」では文字の幅が違うため、列の基準幅も変わります。掲載しているキャプチャの列幅がわずかに不揃いなのは、このためです。きっちり等幅にしたい場合の直し方は実験1にまとめました。

出典: Python公式ドキュメント tkinter（ジオメトリマネージャの説明・pack と grid の混在に関する警告）（原文は英語・2026年8月16日確認）／列幅は筆者環境（Windows 11 / Python 3.12.10 / Tk 8.6）での実測値

4. 完全なソースコード

全体で233行、空行とコメントを除くと185行です。前半が計算のロジック、後半が画面という2段構えになっています。まずはそのままコピーして app002.py という名前で保存し、動く画面を見てしまうのが近道です。1つずつの意味は次の章で分解します。

"""シンプル電卓（tkinter）— eval() を使わない安全な計算ロジック版"""
import ast
import operator
import tkinter as tk

# ------------------------------------------------------------
# 計算ロジック（GUIから独立させておくとテストできる）
# ------------------------------------------------------------
DIGITS = "0123456789"
OPERATORS = "+-*/"

# 許可する演算だけを表に持つ。ここに無い演算はすべて拒否される
_BINARY_OPS = {
    ast.Add: operator.add,
    ast.Sub: operator.sub,
    ast.Mult: operator.mul,
    ast.Div: operator.truediv,
}
_UNARY_OPS = {
    ast.UAdd: operator.pos,
    ast.USub: operator.neg,
}


def safe_eval(expression):
    """数値と + - * / だけからなる式を計算する。

    eval() と違い、許可した種類のノードしか実行しない。
    許可外の式は ValueError を送出する。
    """
    tree = ast.parse(expression, mode="eval")
    return _eval_node(tree.body)


def _eval_node(node):
    """構文木のノードを1つ評価する（再帰）"""
    if isinstance(node, ast.Constant):
        # bool は int のサブクラスなので明示的に弾く
        if isinstance(node.value, bool) or not isinstance(node.value, (int, float)):
            raise ValueError("数値以外のリテラルは使えません")
        return node.value
    if isinstance(node, ast.BinOp) and type(node.op) in _BINARY_OPS:
        left = _eval_node(node.left)
        right = _eval_node(node.right)
        return _BINARY_OPS[type(node.op)](left, right)
    if isinstance(node, ast.UnaryOp) and type(node.op) in _UNARY_OPS:
        return _UNARY_OPS[type(node.op)](_eval_node(node.operand))
    raise ValueError(f"許可されていない式です: {type(node).__name__}")


def current_number(expression):
    """式の末尾にある「入力中の数値」部分を取り出す"""
    i = len(expression)
    while i > 0 and (expression[i - 1] in DIGITS or expression[i - 1] == "."):
        i -= 1
    return expression[i:]


def append_char(expression, char):
    """1文字の入力を式に足す。電卓としての入力ルールはここに集約する"""
    if char in OPERATORS:
        if not expression:
            # 先頭に置けるのはマイナス（負の数）だけ
            return "-" if char == "-" else expression
        if expression[-1] in OPERATORS:
            # 演算子の連打は置き換える（"9**" を作らせない）
            return expression[:-1] + char
        return expression + char

    if char == ".":
        number = current_number(expression)
        if "." in number:
            return expression          # 小数点は1つの数値に1個まで
        if number == "":
            return expression + "0."   # ".5" ではなく "0.5" にする
        return expression + "."

    # ここから数字（想定外の文字は無視する）
    if char not in DIGITS:
        return expression
    if current_number(expression) == "0":
        return expression[:-1] + char  # 先頭のゼロを置き換える（"05" を防ぐ）
    return expression + char


def format_result(value):
    """計算結果を表示用の文字列にする"""
    if isinstance(value, float):
        if value.is_integer():
            return str(int(value))     # 4.0 → 4
        return f"{value:.10g}"         # 0.30000000000000004 → 0.3
    return str(value)


# ------------------------------------------------------------
# GUI
# ------------------------------------------------------------
class Calculator:
    """電卓アプリのメインクラス"""

    # ボタンの定義: (テキスト, 行, 列, columnspan, 背景色)
    BUTTONS = [
        ("C",   1, 0, 1, "#e74c3c"), ("←",  1, 1, 1, "#e67e22"),
        ("%",   1, 2, 1, "#95a5a6"), ("÷",  1, 3, 1, "#3498db"),
        ("7",   2, 0, 1, "#ecf0f1"), ("8",   2, 1, 1, "#ecf0f1"),
        ("9",   2, 2, 1, "#ecf0f1"), ("×",  2, 3, 1, "#3498db"),
        ("4",   3, 0, 1, "#ecf0f1"), ("5",   3, 1, 1, "#ecf0f1"),
        ("6",   3, 2, 1, "#ecf0f1"), ("−",  3, 3, 1, "#3498db"),
        ("1",   4, 0, 1, "#ecf0f1"), ("2",   4, 1, 1, "#ecf0f1"),
        ("3",   4, 2, 1, "#ecf0f1"), ("+",   4, 3, 1, "#3498db"),
        ("0",   5, 0, 2, "#ecf0f1"), (".",   5, 2, 1, "#ecf0f1"),
        ("=",   5, 3, 1, "#2ecc71"),
    ]

    # 画面上の記号 → Python の演算子
    OP_MAP = {"×": "*", "÷": "/", "−": "-"}

    def __init__(self, root):
        self.root = root
        self.root.title("電卓")
        self.root.geometry("280x380")
        self.root.resizable(False, False)
        self.root.configure(bg="#2c3e50")
        self.expression = ""
        self._build_ui()
        self._bind_keyboard()

    def _build_ui(self):
        """UIを構築する"""
        # 表示エリア
        self.display_var = tk.StringVar(value="0")
        display = tk.Label(
            self.root,
            textvariable=self.display_var,
            font=("Arial", 28, "bold"),
            bg="#34495e", fg="white",
            anchor="e", padx=12,
            height=2
        )
        display.grid(row=0, column=0, columnspan=4,
                     sticky="nsew", padx=4, pady=(4, 2))

        # ボタンを生成
        for (text, row, col, span, color) in self.BUTTONS:
            fg = "white" if color != "#ecf0f1" else "#2c3e50"
            btn = tk.Button(
                self.root,
                text=text,
                font=("Arial", 16, "bold"),
                bg=color, fg=fg,
                activebackground=self._darken(color),
                relief=tk.FLAT,
                cursor="hand2",
                command=lambda t=text: self.on_press(t)
            )
            btn.grid(
                row=row, column=col, columnspan=span,
                sticky="nsew", padx=2, pady=2
            )

        # グリッドの重み設定（均等に拡張）
        for i in range(4):
            self.root.columnconfigure(i, weight=1)
        for i in range(6):
            self.root.rowconfigure(i, weight=1)

    def _darken(self, hex_color):
        """押したときの色を少し暗くする"""
        mapping = {
            "#ecf0f1": "#bdc3c7", "#3498db": "#2980b9",
            "#e74c3c": "#c0392b", "#2ecc71": "#27ae60",
            "#e67e22": "#d35400", "#95a5a6": "#7f8c8d",
        }
        return mapping.get(hex_color, hex_color)

    def _bind_keyboard(self):
        """キーボード入力をバインドする"""
        # bind には記号そのものではなく keysym 名を使う
        key_map = {
            "Key-0": "0", "Key-1": "1", "Key-2": "2", "Key-3": "3", "Key-4": "4",
            "Key-5": "5", "Key-6": "6", "Key-7": "7", "Key-8": "8", "Key-9": "9",
            "plus": "+", "minus": "−", "asterisk": "×", "slash": "÷",
            "period": ".", "Return": "=", "BackSpace": "←", "Escape": "C",
        }
        for key, action in key_map.items():
            self.root.bind(f"<{key}>", lambda e, a=action: self.on_press(a))

    def on_press(self, char):
        """ボタン押下時の処理"""
        if char == "C":
            self.expression = ""
            self._show("0")
        elif char == "←":
            self.expression = self.expression[:-1]
            self._show(self.expression or "0")
        elif char == "=":
            self._calculate()
        elif char == "%":
            self._calculate(percent=True)
        else:
            self.expression = append_char(
                self.expression, self.OP_MAP.get(char, char))
            self._show(self.expression or "0")

    def _calculate(self, percent=False):
        """式を計算して表示する（% のときは percent=True）"""
        try:
            result = safe_eval(self.expression)
            if percent:
                result = result / 100
            text = format_result(result)
        except ZeroDivisionError:
            self._error("0除算エラー")          # 1/0 のとき
        except (SyntaxError, ValueError):
            self._error("入力エラー")            # 式が未完成・許可外のとき
        except OverflowError:
            self._error("桁あふれ")              # 極端に大きい値のとき
        else:
            self.expression = text
            self._show(text)

    def _show(self, text):
        self.display_var.set(text)

    def _error(self, message):
        self.display_var.set(message)
        self.expression = ""


if __name__ == "__main__":
    root = tk.Tk()
    app = Calculator(root)
    root.mainloop()

実行はターミナルで python app002.py です（Windowsで python が反応しないときは py app002.py）。ウィンドウが出てこない場合は、tkinterそのものが使えるかどうかの切り分けをtkinterが使えるか30秒で確認するにまとめてあります。

5. コード解説（部品ごとに）

上から順に、意味のかたまりごとに見ていきます。長く見えますが、やっていることは「押された文字を足す」「式を計算する」「表示する」の3つだけです。

5-1. import と、許可する演算の表

import ast
import operator
import tkinter as tk

DIGITS = "0123456789"
OPERATORS = "+-*/"

_BINARY_OPS = {
    ast.Add: operator.add,
    ast.Sub: operator.sub,
    ast.Mult: operator.mul,
    ast.Div: operator.truediv,
}

ast は、Pythonのコードを「構文木」という形に分解する標準ライブラリです。operator は + や * といった演算を関数の形で持っているモジュールで、operator.add(2, 3) は 2 + 3 と同じ意味になります。

この辞書と、同じ形で書いた符号用の _UNARY_OPS（4章のコードの19〜22行目）が、この電卓の安全装置の本体です。ここに書いた6種類——四則演算の4つと、符号のプラス・マイナスの2つ——しか実行しないと決めてしまいます。累乗（**）や関数呼び出しは表にないので、書かれていても実行されません。

5-2. ボタンの一括生成と lambda の落とし穴

for (text, row, col, span, color) in self.BUTTONS:
    fg = "white" if color != "#ecf0f1" else "#2c3e50"
    btn = tk.Button(
        self.root,
        text=text,
        font=("Arial", 16, "bold"),
        bg=color, fg=fg,
        activebackground=self._darken(color),
        relief=tk.FLAT,
        cursor="hand2",
        command=lambda t=text: self.on_press(t)
    )

注目してほしいのは command=lambda t=text: self.on_press(t) の t=text です。ここを lambda: self.on_press(text) と書くと、19個のボタンすべてが「=」として動きます。

理由は、lambdaの中の text が「押されたときに」評価されるからです。押されるころにはループは終わっていて、text にはリストの最後の値だけが残っています。t=text と引数のデフォルト値にしておくと、lambdaを作った瞬間の値がその場で固定されます。ボタンをループで作るときの定番の書き方なので、形ごと覚えてしまって構いません。症状としての見え方は9章にまとめました。

5-3. append_char(): 押された文字を式に足す

電卓の「入力ルール」を全部ここに集めています。単純に文字をつなげるだけだと、正しく計算できない式が簡単にできてしまうためです。

def append_char(expression, char):
    """1文字の入力を式に足す。電卓としての入力ルールはここに集約する"""
    if char in OPERATORS:
        if not expression:
            return "-" if char == "-" else expression
        if expression[-1] in OPERATORS:
            return expression[:-1] + char       # 演算子の連打は置き換える
        return expression + char

    if char == ".":
        number = current_number(expression)
        if "." in number:
            return expression                   # 小数点は1つの数値に1個まで
        if number == "":
            return expression + "0."
        return expression + "."

    if char not in DIGITS:
        return expression
    if current_number(expression) == "0":
        return expression[:-1] + char           # 先頭のゼロを置き換える
    return expression + char

この関数は引数と戻り値だけで完結していて、画面にも self にも触りません。だからウィンドウを開かずにテストできます。実際に押した順を渡して確かめた結果が次の表です。

2番目までが、先頭のゼロの話です。Python 3では 05 のような書き方が構文エラーになります。筆者が実際に出したメッセージは次のとおりでした。

>>> eval("05")
SyntaxError: leading zeros in decimal integer literals are not permitted;
use an 0o prefix for octal integers

「0を押してから5を押す」は、電卓では誰でもやる操作です。入力を組み立てる段階で潰しておかないと、実際の利用でエラー表示が出ます。3番目の 9**9 も同じで、×を2回押しただけで累乗の式ができてしまいます。これがどれだけ危ないかは6章で数字を出します。

5-4. safe_eval(): 式を構文木にしてからたどる

ここがこのページの中心です。文字列をそのまま実行するのではなく、いったん構文木という形に分解し、許可した種類のノードだけを自分で計算します。

def safe_eval(expression):
    tree = ast.parse(expression, mode="eval")
    return _eval_node(tree.body)


def _eval_node(node):
    if isinstance(node, ast.Constant):
        if isinstance(node.value, bool) or not isinstance(node.value, (int, float)):
            raise ValueError("数値以外のリテラルは使えません")
        return node.value
    if isinstance(node, ast.BinOp) and type(node.op) in _BINARY_OPS:
        left = _eval_node(node.left)
        right = _eval_node(node.right)
        return _BINARY_OPS[type(node.op)](left, right)
    if isinstance(node, ast.UnaryOp) and type(node.op) in _UNARY_OPS:
        return _UNARY_OPS[type(node.op)](_eval_node(node.operand))
    raise ValueError(f"許可されていない式です: {type(node).__name__}")

ast.parse(expression, mode="eval") は、公式ドキュメントの説明では「単一の式をパースする」モードです。文字列を解析して木の形にするだけで、この時点では何も実行されません。"2+3*4" なら、足し算のノードの下に数値の2と、かけ算のノードがぶら下がり、そのさらに下に3と4がぶら下がる形になります。

あとは _eval_node() が木を上からたどるだけです。数値ならそのまま返し、演算のノードなら左右をそれぞれ評価してから許可表の関数を呼びます。表にない種類のノードに出会った時点で ValueError で止まります。実際に試した結果が次のとおりです。

ポイントは、禁止したいものを列挙するのではなく、許可するものだけを列挙していることです。禁止リスト方式は「書き忘れた1つ」が穴になりますが、許可リスト方式なら、知らない書き方が来ても自動的に弾かれます。

5-5. format_result(): 結果を読める形にする

def format_result(value):
    if isinstance(value, float):
        if value.is_integer():
            return str(int(value))     # 4.0 → 4
        return f"{value:.10g}"         # 0.30000000000000004 → 0.3
    return str(value)

Pythonの / は、割り切れる場合でも小数を返します。8/4 は 2.0 です。電卓の表示としては不格好なので、is_integer() で「小数点以下がない小数」を判定して整数に直しています。

もう1つの f"{value:.10g}" は、有効数字10桁で表示する書式です。これがないと 0.1+0.2 の結果が 0.30000000000000004 と表示されます。バグではなく、コンピュータが2進数で小数を扱うことによる誤差です。表示だけを丸めているので、内部の値は変えていません。お金の計算のように誤差を持ち込みたくない場合の対処は実験4に書きました。

5-6. キーボードから入力できるようにする

key_map = {
    "Key-0": "0", "Key-1": "1", "Key-2": "2", "Key-3": "3", "Key-4": "4",
    "Key-5": "5", "Key-6": "6", "Key-7": "7", "Key-8": "8", "Key-9": "9",
    "plus": "+", "minus": "−", "asterisk": "×", "slash": "÷",
    "period": ".", "Return": "=", "BackSpace": "←", "Escape": "C",
}
for key, action in key_map.items():
    self.root.bind(f"<{key}>", lambda e, a=action: self.on_press(a))

18個のキーを、ボタンと同じ処理につないでいます。ここでも a=action というデフォルト引数が出てきます。理由は5-2と同じです。

bind() に渡す文字列は、公式ドキュメントによれば <修飾キー-種類-詳細> という形式です。この「詳細」の部分に何を書けるかで、初心者はよくつまずきます。筆者が実際に11通りの書き方を試した結果が次の表です（4つのグループに分けて示します）。

つまり「記号はそのまま書けない」わけではありません。書けないのはハイフンだけで、本当に危ないのは数字です。<1> はマウスのボタン1という意味に解釈されるため、数字キーは <Key-1> と書く必要があります。迷ったときは全部 keysym 名で書いておけば事故が起きません。

5-7. 失敗したときの後始末

def _calculate(self, percent=False):
    try:
        result = safe_eval(self.expression)
        if percent:
            result = result / 100
        text = format_result(result)
    except ZeroDivisionError:
        self._error("0除算エラー")          # 1/0 のとき
    except (SyntaxError, ValueError):
        self._error("入力エラー")            # 式が未完成・許可外のとき
    except OverflowError:
        self._error("桁あふれ")              # 極端に大きい値のとき
    else:
        self.expression = text
        self._show(text)

電卓は「間違った入力をされる前提」で作る必要があります。except を3つに分けているのは、原因ごとに違う文言を出すためです。ひとまとめに except Exception と書くこともできますが、それだと自分のコードのバグまで「エラー」の一言で隠れてしまい、直せなくなります。

else の中で初めて self.expression を書き換えている点も大事です。失敗したときは _error() の中で式を空に戻すので、エラー表示のあとに数字を押せば新しい計算を始められます。個別のエラーの読み方はPythonエラー一覧＆解決法にまとめてあります。

出典: Python公式ドキュメント ast（ast.parse の mode 引数）／同 tkinter（bind の sequence 形式）（いずれも2026年8月16日確認）。実測値は筆者環境（Windows 11 / Python 3.12.10 / Tk 8.6）での測定

6. なぜ eval() を使わないのか

電卓の作り方を調べると、計算部分がこの1行になっている例をよく見かけます。

result = eval(self.expression)   # 手軽だが、電卓では使わないほうがいい

たしかに動きます。eval("2+3*4") は 14 を返します。優先順位もかっこも自分で実装しなくて済むので、入門記事で選ばれるのは自然なことです。ただし公式ドキュメントは、この関数についてはっきり警告しています。

「この関数は任意のコードを実行します。 信頼できないユーザ入力にて この関数を呼び出すと、セキュリティの脆弱性につながります。」（Python公式ドキュメント 組み込み関数 eval・2026年8月16日確認）

「でも、この電卓には数字と演算子のボタンしかない。文字は入力できないのだから安全では？」と思うかもしれません。筆者も最初はそう考えていました。実際に試したところ、そうではありませんでした。

実測1: ボタンを7回押すだけで、2秒以上フリーズする式が作れる

eval() をそのまま使い、入力ルールを入れていない実装では、×ボタンを2回続けて押すと式に ** が並びます（このページの append_char() は連打を置き換えるため、掲載コードでは起きません）。Pythonでは ** は累乗です。つまり 9 → × → × → 9 → × → × → 7 の7回で、9**9**7 という式ができあがります。この式の計算にかかった時間を測りました。

この計算はイベントループの中で走ります。tkinterのウィンドウが固まる原因と同じで、計算が終わるまでウィンドウは再描画もクリックも受け付けません。悪意のある誰かではなく、ボタンを連打しただけのユーザーが自分でアプリを固められるということです。

実測2: 計算できても、表示でエラーになる

おもしろいことに、桁数の大きい結果は計算に成功しても表示できません。

>>> str(9**9**4)
ValueError: Exceeds the limit (4300 digits) for integer string conversion;
use sys.set_int_max_str_digits() to increase the limit

これは、巨大な整数を文字列にする処理が重くなりすぎることへの、Python側の安全装置です。eval() を使った実装では、この ValueError も「エラー」と表示して終わることになります。ユーザーには何が起きたか分かりません。

実測3: 入力欄を1つ足した瞬間に穴になる

電卓を作ったあと、「式を直接打ち込めるようにしたい」と tk.Entry を足すのは自然な発展です。その瞬間、eval() は任意のコードの実行口になります。

eval("__import__('os').listdir('.')")   # フォルダの中身が読める

これに対して「危ない名前を禁止すればいい」「__builtins__ を空にすればいい」という対策が紹介されることがありますが、公式ドキュメントはその方法についてもこう書いています。

「__builtins__ の上書きで 利用可能な名前を制限や変更できますが、これはセキュリティ機構ではありません：実行されるコードは依然として全組み込み機能にアクセスできます。」（Python公式ドキュメント 組み込み関数 eval・2026年8月16日確認）

禁止リストを育てる方向は、公式が「セキュリティ機構ではない」と明言している道です。だから5-4のように、許可する演算を6つだけ書いて、それ以外は全部拒否する方式にしました。コード量は増えますが、増えるのは37行（空行を除くと32行）です。

まとめると、学習用の電卓で eval() を使うこと自体が即座に事故になるわけではありません。ただ、「ユーザーが打った文字列を計算する」という処理は、実務でもそのまま出てくる形です。最初に安全な形で覚えておくほうが、あとで書き換える手間より確実に安く済みます。

ただし safe_eval() にすれば何でも安全になるわけではありません。任意のコードが実行されるタイプの危険はなくなりますが、桁数の大きい計算に時間がかかることや、極端に長い式で解析側が限界を迎えることは残ります。限界と追加の対策は11章のQ&Aにまとめました。

出典: Python公式ドキュメント 組み込み関数 eval／同 ast（literal_eval の注意書き・原文は英語／訳は筆者）（いずれも2026年8月16日確認）。時間と桁数は筆者環境（Windows 11 / Python 3.12.10）での実測値で、環境によって変わります

7. 空のウィンドウから作る7ステップ

233行をいきなり写経すると、どこで間違えたのか分からなくなります。空のウィンドウから始めて、1ステップごとに実行して確認するのが結局いちばん速い進み方です。各ステップの終わりで必ず一度実行してください。

1. 1
   空のウィンドウを出す

   まず土台だけ作ります。ここで灰色のウィンドウが出れば、環境は問題ありません。出ない場合は先にHello Worldの記事で切り分けてください。

   import tkinter as tk
   
   root = tk.Tk()
   root.title("電卓")
   root.geometry("280x380")
   root.mainloop()

2. 2
   表示欄を1つ置く

   StringVar と結びつけたラベルを、1行目に4列ぶち抜きで置きます。anchor="e" で電卓らしく右寄せになります。mainloop() より上に書いてください。

   display_var = tk.StringVar(value="0")
   display = tk.Label(root, textvariable=display_var, font=("Arial", 28, "bold"),
                      bg="#34495e", fg="white", anchor="e", padx=12, height=2)
   display.grid(row=0, column=0, columnspan=4, sticky="nsew", padx=4, pady=(4, 2))

3. 3
   ボタンを4個だけ並べてみる

   いきなり19個作らず、まず1行分で位置の感覚をつかみます。押したらターミナルに文字が出るだけの形にしておくと、配置の確認に集中できます。

   for i, text in enumerate(["7", "8", "9", "×"]):
       tk.Button(root, text=text, font=("Arial", 16, "bold"),
                 command=lambda t=text: print(t)).grid(
           row=2, column=i, sticky="nsew", padx=2, pady=2)

4. 4
   19個をリストから一括生成する

   位置の感覚がつかめたら、3章の BUTTONS リストに置き換えます。ここで columnconfigure と rowconfigure も入れて、ウィンドウいっぱいに広がることを確認してください。

5. 5
   押した文字を表示欄に出す

   まだ計算はしません。押した文字をつなげて表示するだけにします。数字と演算子が画面に並んでいくのを見ると、電卓の正体が「1本の文字列」だと実感できます。

   expression = ""
   
   
   def on_press(char):
       global expression
       expression += char
       display_var.set(expression)

6. 6
   入力ルールと計算をつなぐ

   5章の append_char() と safe_eval() を追加し、= が押されたときに呼びます。ここまでで電卓として使えるようになります。

7. 7
   クラスにまとめ、キーボードとエラー処理を足す

   global が増えてきたら、クラスにまとめる合図です。ウィジェットと式を self. で持たせると、関数の間で値を受け渡す悩みが消えます。最後に try-except とキーボードの bind() を足せば、4章の完成形と同じになります。

8. 自分でいじって試す5つの実験

写経が終わったら、次は1か所ずつ書き換えて結果を見る番です。どれも数分で試せます。

for i in range(4):
    root.columnconfigure(i, weight=1, uniform="calc")

from app002 import append_char, safe_eval, format_result


def press(keys):
    """ボタンを順番に押したときの式を返す"""
    expression = ""
    for key in keys:
        expression = append_char(expression, key)
    return expression


cases = [
    ("05", "5"),
    ("12+05", "12+5"),
    ("9**9", "9*9"),
    (".5", "0.5"),
    ("365*24*60*60", "365*24*60*60"),
]
for keys, expected in cases:
    got = press(keys)
    print("OK " if got == expected else "NG ", keys, "→", got)

print(format_result(safe_eval("365*24*60*60")))
print(format_result(safe_eval("0.1+0.2")))

OK  05 → 5
OK  12+05 → 12+5
OK  9**9 → 9*9
OK  .5 → 0.5
OK  365*24*60*60 → 365*24*60*60
31536000
0.3

("(",   6, 0, 1, "#95a5a6"), (")",   6, 1, 1, "#95a5a6"),

from decimal import Decimal

print(0.1 + 0.2)                          # 0.30000000000000004
print(Decimal("0.1") + Decimal("0.2"))    # 0.3

self.history.append(f"{before} = {text}")   # before は計算前の式

9. うまく動かないときの症状別チェック

GUIは「エラーが出ないのに思ったとおりにならない」ことがあります。まず症状から当たりを付けてください。

# NG: 押した時点の text を見にいく
command=lambda: self.on_press(text)

# OK: 作った時点の値を t に固定する
command=lambda t=text: self.on_press(t)

# NG: 作った瞬間に実行され、command には戻り値が入る
command=self.on_press("1")

# OK: 押されたときに呼ばれる形にする
command=lambda t="1": self.on_press(t)

root.columnconfigure(i, weight=1, uniform="calc")

root.bind("<Key-1>", handler)     # 数字キーの1
root.bind("<plus>", handler)      # +
root.bind("<minus>", handler)     # -（<-> は書けない）
root.bind("<Return>", handler)    # Enter

SyntaxError: leading zeros in decimal integer literals are not permitted;
use an 0o prefix for octal integers

print(f"{0.1 + 0.2:.10g}")   # 0.3

try:
    result = safe_eval(self.expression)
except ZeroDivisionError:
    self._error("0除算エラー")

出典: 症状と対処は筆者環境（Windows 11 / Python 3.12.10 / Tk 8.6）で再現・確認したもの。仕様の裏取りはPython公式ドキュメント tkinter（2026年8月16日確認）

10. 練習問題

手を動かして初めて身につきます。ヒントだけ添えるので、答えを見る前に自分で書いてみてください。

1. 課題1: 符号反転ボタン（±）を付ける

   表示中の数値の符号を入れ替えるボタンを追加しましょう。
   ヒント: 式全体を計算してから -1 をかける方法と、いま入力中の数値だけを取り出して符号を付ける方法があります。後者には current_number() が使えます。

2. 課題2: メモリ機能（M+ / MR / MC）

   計算結果をためる M+、呼び出す MR、消す MC の3つのボタンを追加しましょう。
   ヒント: self.memory = 0 を __init__ に用意します。表示のたびに BUTTONS を書き換える必要はありません。行を1つ増やして rowconfigure の範囲を range(7) にします。

3. 課題3: 直前の計算をやり直す

   = を押した直後にもう一度 = を押すと、同じ演算をもう1回適用する機能を作りましょう（3+4= のあと = を押すと 11）。
   ヒント: 最後に使った演算子と右側の数値を覚えておく必要があります。self.last_operation のような属性を足します。

4. 課題4: 許可する演算を1つ増やす

   safe_eval() に剰余（%、割った余り）を追加してみましょう。
   ヒント: _BINARY_OPS に ast.Mod: operator.mod を足します。画面の % ボタンはパーセント計算に使っているので、ボタンの割り当てをどうするかも考えてみてください。

11. よくある質問

Q. 電卓を作るのに追加のインストールは必要ですか？

不要です。tkinterはPythonの標準ライブラリで、ast と operator も標準です。pip install は1つも要りません。ただしLinuxのディストリビューションによっては、tkinterが別パッケージになっていることがあります。判断は python -m tkinter の結果で付けてください（確認手順）。

Q. なぜ多くの入門記事は eval() を使っているのですか？

1行で書けて、演算子の優先順位もかっこも自動で処理されるからです。入門者に見せるコードとしては読みやすく、選ばれる理由はよく分かります。このページでは、ボタン操作だけで2秒以上フリーズする式が作れることを実測したうえで、37行（空行を除くと32行）増やして安全な形にしました（6章）。学習用として eval() の動きを知っておくこと自体は有益です。

Q. safe_eval() を使えば完全に安全ですか？

「任意のコードが実行される」タイプの危険はなくなりますが、完全ではありません。たとえばかけ算だけでも、桁数の大きい数を何度もかければ計算に時間がかかります。Python公式ドキュメント ast も、構文解析そのものについて「十分に大きい文字列や複雑な文字列によってPythonの抽象構文木コンパイラのスタックの深さの限界を越えることで、Pythonインタプリタをクラッシュさせることができます」と注意しています（2026年8月16日確認）。外部からの入力を受け付けるアプリでは、式の長さや桁数に上限を設けるなど、別の対策も必要になります。

Q. ボタンを2次元リストで作る書き方との違いは？

どちらでも構いません。2次元リスト（[["7","8","9","×"], ...]）は見た目が画面に近く、行と列を enumerate() で自動的に決められるのが利点です。このページで1次元のタプルにしているのは、columnspan と色をボタンごとに変えたかったからです。0のボタンだけ2列分にする、といった例外がある画面では、こちらのほうが素直に書けます。

Q. 演算子の優先順位は自分で実装しなくていいのですか？

必要ありません。ast.parse() がPythonの文法どおりに解釈するので、2+3*4 は 14 になります。かっこ付きの (1+2)*3 も 9 になりました。優先順位の処理を自分で書くのは、電卓を「文字列を左から順に処理する」方式で作った場合の話です。

Q. macOSやLinuxでも同じコードが動きますか？

tkinterはmacOSを含むほとんどのUnix系プラットフォームとWindowsで使えるため、コードはそのまま動く想定です。ただしボタンの見た目・フォント・ウィンドウの余白は環境によって変わります。このページの実測値はWindows 11のものです。当サイトでは Windows 11 と Linux Mint 22.3 で起動を確認しました（1章の4枚目が Linux Mint の画面です）。macOS は未検証です。ボタンの色や大きさの見え方はOSごとに差が出るため、他の環境で作る場合は色の指定を微調整してください。

Q. 表示が「入力エラー」から戻らなくなりました。元に戻すにはどうすればいいですか？

エラー表示のあとは式が空に戻っているので、数字を押せば新しい計算を始められます。もし数字を押しても何も起きない場合は、_error() の中で self.expression = "" を実行しているか確認してください。表示だけ変えて式を残すと、次に押した数字が壊れた式の後ろに付いてしまいます。

Q. コードは動いたけれど、ast の部分がよく分かりません。このまま次に進んでいいですか？

それで問題ありません。safe_eval() は関数として完結しているので、中身が分からなくても「数字と四則演算だけを計算してくれる部品」として使えます。1本作るごとに1つ増やせば十分です。まずは基本構文と関数を固めて、次のアプリで同じ形が出てきたときに読み返してください。

12. 次の一歩

電卓が動いたら、次は同じ部品の組み合わせで、扱うデータを変える段階です。1本ごとに新しい要素を1つだけ足していくのが、結局いちばん速い進み方です。

同じ電卓でも sin・cos・log・√ まで扱いたい方は、科学電卓（No.076）へ進めます。このページは四則演算と「eval()を使わない計算ロジック」、科学電卓は math モジュールで関数を足していく回という住み分けです。grid() でボタンを並べる考え方はそのまま使い回せます。なお科学電卓のページは、math の関数に __builtins__ を空で添えた辞書を渡して eval() を呼ぶ実装です（呼べる名前は絞られますが、上の公式引用のとおりこれはセキュリティ機構ではありません）。6章の理由から、外部からの入力を受け取る形に育てるときは、このページの許可リスト方式に置き換えてください。

作りたいものが決まっていないときは初心者用GUIアプリ一覧から好きなものを選んでください。標準ライブラリの外に出て何ができるかを知りたい方はPythonライブラリ一覧、独学の順番を1冊で固めたい方はPython学習本の比較もどうぞ。