Pythonの処理終了を簡単に実行する方法10選

def check_adult(age):
    if age >= 20:
        return "成人です"
    return "未成年です"

# 関数の使用例
result = check_adult(25)
print(result)  # 出力: 成人です

result = check_adult(18)
print(result)  # 出力: 未成年です

import sys

def critical_operation():
    # 重要な操作をシミュレート
    success = False
    if not success:
        print("致命的なエラーが発生しました。プログラムを終了します。")
        sys.exit(1)
    print("操作が成功しました。")

# プログラムの実行
print("プログラムを開始します。")
critical_operation()
print("この行は実行されません。")

プログラムを開始します。
致命的なエラーが発生しました。プログラムを終了します。

def find_first_multiple_of_seven():
    for num in range(1, 101):
        if num % 7 == 0:
            print(f"最初の7の倍数: {num}")
            return num
    print("7の倍数は見つかりませんでした。")
    return None

result = find_first_multiple_of_seven()
print(f"関数の戻り値: {result}")

最初の7の倍数: 7
関数の戻り値: 7

def sum_until_hundred():
    total = 0
    while True:
        user_input = input("数字を入力してください（合計が100を超えると終了）: ")
        if user_input.lower() == 'q':
            print("ユーザーが入力を中止しました。")
            break
        try:
            number = float(user_input)
            total += number
            print(f"現在の合計: {total}")
            if total > 100:
                print("合計が100を超えました。")
                break
        except ValueError:
            print("無効な入力です。数字を入力してください。")
    return total

final_sum = sum_until_hundred()
print(f"最終的な合計: {final_sum}")

数字を入力してください（合計が100を超えると終了）: 30
現在の合計: 30.0
数字を入力してください（合計が100を超えると終了）: 50
現在の合計: 80.0
数字を入力してください（合計が100を超えると終了）: 25
現在の合計: 105.0
合計が100を超えました。
最終的な合計: 105.0

def find_element(matrix, target):
    found = False
    for i, row in enumerate(matrix):
        for j, element in enumerate(row):
            if element == target:
                print(f"{target}が見つかりました。位置: ({i}, {j})")
                found = True
                break
        if found:
            break
    if not found:
        print(f"{target}は見つかりませんでした。")

# 2次元リストの例
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

find_element(matrix, 5)
find_element(matrix, 10)

5が見つかりました。位置: (1, 1)
10は見つかりませんでした。

def calculate_reciprocal():
    try:
        user_input = input("数字を入力してください: ")
        number = float(user_input)
        reciprocal = 1 / number
        print(f"{number}の逆数は{reciprocal}です。")
    except ValueError:
        print("エラー: 有効な数字を入力してください。")
        return False
    except ZeroDivisionError:
        print("エラー: ゼロの逆数は定義されていません。")
        return False
    except Exception as e:
        print(f"予期せぬエラーが発生しました: {e}")
        return False
    else:
        print("計算が正常に完了しました。")
        return True
    finally:
        print("プログラムを終了します。")

success = calculate_reciprocal()
print(f"プログラムの実行結果: {'成功' if success else '失敗'}")

数字を入力してください: 4
4.0の逆数は0.25です。
計算が正常に完了しました。
プログラムを終了します。
プログラムの実行結果: 成功

数字を入力してください: 0
エラー: ゼロの逆数は定義されていません。
プログラムを終了します。
プログラムの実行結果: 失敗

数字を入力してください: abc
エラー: 有効な数字を入力してください。
プログラムを終了します。
プログラムの実行結果: 失敗

def process_file(filename):
    file = None
    try:
        file = open(filename, 'r')
        content = file.read()
        processed_content = content.upper()
        print(f"処理後の内容:\n{processed_content}")

        # 結果を新しいファイルに書き込む
        with open(f"processed_{filename}", 'w') as output_file:
            output_file.write(processed_content)

        print(f"処理結果を 'processed_{filename}' に保存しました。")
    except FileNotFoundError:
        print(f"エラー: ファイル '{filename}' が見つかりません。")
    except IOError as e:
        print(f"ファイル操作中にエラーが発生しました: {e}")
    except Exception as e:
        print(f"予期せぬエラーが発生しました: {e}")
    finally:
        if file:
            file.close()
            print("ファイルを閉じました。")
        print("プログラムを終了します。")

# プログラムの実行
filename = input("処理するファイル名を入力してください: ")
process_file(filename)

処理するファイル名を入力してください: sample.txt
処理後の内容:
HELLO, WORLD!
THIS IS A SAMPLE FILE.
処理結果を 'processed_sample.txt' に保存しました。
ファイルを閉じました。
プログラムを終了します。

処理するファイル名を入力してください: nonexistent.txt
エラー: ファイル 'nonexistent.txt' が見つかりません。
プログラムを終了します。

import sys

def check_user_input():
    user_input = input("1から3までの数字を入力してください: ")
    try:
        number = int(user_input)
        if 1 <= number <= 3:
            print(f"入力された数字は {number} です。正常に終了します。")
            sys.exit(0)  # 正常終了
        else:
            print("エラー: 1から3の範囲外の数字が入力されました。")
            sys.exit(1)  # 異常終了 (範囲外の入力)
    except ValueError:
        print("エラー: 有効な数字が入力されませんでした。")
        sys.exit(2)  # 異常終了 (数字以外の入力)

if __name__ == "__main__":
    check_user_input()

1から3までの数字を入力してください: 2
入力された数字は 2 です。正常に終了します。
(終了コード: 0)

1から3までの数字を入力してください: 5
エラー: 1から3の範囲外の数字が入力されました。
(終了コード: 1)

1から3までの数字を入力してください: abc
エラー: 有効な数字が入力されませんでした。
(終了コード: 2)

import atexit
import time

def exit_handler():
    print("プログラムが終了します。最終クリーンアップを実行中...")
    time.sleep(1)  # クリーンアップ処理のシミュレーション
    print("クリーンアップが完了しました。さようなら！")

atexit.register(exit_handler)

def main():
    print("メインプログラムを実行中...")
    # ここに通常のプログラムのロジックを記述
    print("メインプログラムが終了しました。")

if __name__ == "__main__":
    main()
    # プログラムが終了する際に、自動的にexit_handler()が呼び出されます

メインプログラムを実行中...
メインプログラムが終了しました。
プログラムが終了します。最終クリーンアップを実行中...
クリーンアップが完了しました。さようなら！

import signal
import sys
import time

def signal_handler(sig, frame):
    print('\nプログラムが中断されました。クリーンアップを実行します...')
    time.sleep(1)  # クリーンアップ処理のシミュレーション
    print('クリーンアップが完了しました。プログラムを終了します。')
    sys.exit(0)

signal.signal(signal.SIGINT, signal_handler)

def main():
    print("プログラムが起動しました。Ctrl+Cで中断できます。")
    try:
        while True:
            print("処理中...", end='\r')
            time.sleep(1)
    except KeyboardInterrupt:
        pass  # signal_handlerが処理するため、ここでは何もしない

if __name__ == "__main__":
    main()

プログラムが起動しました。Ctrl+Cで中断できます。
処理中...処理中...処理中...
^C
プログラムが中断されました。クリーンアップを実行します...
クリーンアップが完了しました。プログラムを終了します。

def process_large_file(filename):
    try:
        with open(filename, 'r') as file:
            for line in file:
                # ファイルの各行を処理
                process_line(line)
    except IOError as e:
        print(f"ファイル処理中にエラーが発生しました: {e}")
    finally:
        print("ファイル処理が完了しました。")

def process_line(line):
    # 行の処理ロジック
    pass

# 使用例
process_large_file('large_data.txt')

def process_large_data(data_generator):
    try:
        for item in data_generator:
            # 各データ項目を処理
            process_item(item)
    except Exception as e:
        print(f"データ処理中にエラーが発生しました: {e}")
    finally:
        print("データ処理が完了しました。")

def data_generator(n):
    for i in range(n):
        yield i  # 大量のデータをシミュレート

def process_item(item):
    # 項目の処理ロジック
    pass

# 使用例
process_large_data(data_generator(1000000))

import threading
import time
import signal
import sys

class WorkerThread(threading.Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name
        self._stop_event = threading.Event()

    def run(self):
        while not self._stop_event.is_set():
            print(f"スレッド {self.name} が動作中...")
            time.sleep(1)
        print(f"スレッド {self.name} が終了しました。")

    def stop(self):
        self._stop_event.set()

def signal_handler(signum, frame):
    print("\nプログラムの終了を開始します...")
    for thread in threads:
        thread.stop()
    for thread in threads:
        thread.join()
    print("全てのスレッドが終了しました。プログラムを終了します。")
    sys.exit(0)

if __name__ == "__main__":
    signal.signal(signal.SIGINT, signal_handler)

    threads = [WorkerThread("A"), WorkerThread("B"), WorkerThread("C")]
    for thread in threads:
        thread.start()

    print("メインプログラムが動作中です。Ctrl+Cで終了できます。")

    # メインスレッドを動作させ続ける
    while True:
        time.sleep(1)

メインプログラムが動作中です。Ctrl+Cで終了できます。
スレッド A が動作中...
スレッド B が動作中...
スレッド C が動作中...
スレッド A が動作中...
スレッド B が動作中...
スレッド C が動作中...
^C
プログラムの終了を開始します...
スレッド A が終了しました。
スレッド B が終了しました。
スレッド C が終了しました。
全てのスレッドが終了しました。プログラムを終了します。

def find_number(numbers, target):
    for num in numbers:
        if num == target:
            print(f"{target}が見つかりました。")
            break
        print(f"{num}はターゲットではありません。")
    print("探索が終了しました。")

numbers = [1, 2, 3, 4, 5]
find_number(numbers, 3)

1はターゲットではありません。
2はターゲットではありません。
3が見つかりました。
4はターゲットではありません。
5はターゲットではありません。
探索が終了しました。

def find_number(numbers, target):
    for num in numbers:
        if num == target:
            print(f"{target}が見つかりました。")
            break
        print(f"{num}はターゲットではありません。")
    print("探索が終了しました。")

numbers = [1, 2, 3, 4, 5]
find_number(numbers, 3)

1はターゲットではありません。
2はターゲットではありません。
3が見つかりました。
探索が終了しました。

import time

def countdown_with_interrupt():
    count = 10
    while True:
        print(f"カウントダウン: {count}")
        time.sleep(1)
        count -= 1
        if count < 0:
            count = 10

        # ユーザー入力をチェック
        user_input = input("'q'を入力して終了、または他のキーで続行: ")
        if user_input.lower() == 'q':
            print("プログラムを終了します。")
            break

countdown_with_interrupt()

カウントダウン: 10
'q'を入力して終了、または他のキーで続行: 
カウントダウン: 9
'q'を入力して終了、または他のキーで続行: 
カウントダウン: 8
'q'を入力して終了、または他のキーで続行: q
プログラムを終了します。

while True:
    print("このループは永遠に続きます...")

このループは永遠に続きます...
このループは永遠に続きます...
このループは永遠に続きます...
Traceback (most recent call last):
  File "infinite_loop.py", line 2, in <module>
    print("このループは永遠に続きます...")
KeyboardInterrupt

import time
import sys
import signal
import pickle

class DataProcessor:
    def __init__(self, data):
        self.data = data
        self.current_index = 0
        self.results = []

    def process_data(self):
        while self.current_index < len(self.data):
            item = self.data[self.current_index]
            result = self.process_item(item)
            self.results.append(result)
            self.current_index += 1

            # 進捗を表示
            print(f"処理中: {self.current_index}/{len(self.data)} 完了", end='\r')

            # 処理を遅くするためのスリープ（実際のアプリケーションでは不要）
            time.sleep(0.1)

    def process_item(self, item):
        # ここで実際のデータ処理を行う（この例では単純に2倍にする）
        return item * 2

    def save_state(self):
        with open('processor_state.pkl', 'wb') as f:
            pickle.dump((self.current_index, self.results), f)
        print("\n現在の状態を保存しました。")

    def load_state(self):
        try:
            with open('processor_state.pkl', 'rb') as f:
                self.current_index, self.results = pickle.load(f)
            print(f"前回の状態を読み込みました。インデックス: {self.current_index}")
        except FileNotFoundError:
            print("保存された状態が見つかりません。最初から処理を開始します。")

def signal_handler(signum, frame):
    print("\n処理を中断します。状態を保存しています...")
    processor.save_state()
    sys.exit(0)

# シグナルハンドラを設定
signal.signal(signal.SIGINT, signal_handler)

# サンプルデータの作成
data = list(range(1, 101))  # 1から100までの数字のリスト

# DataProcessorのインスタンスを作成
processor = DataProcessor(data)

# 前回の状態を読み込む
processor.load_state()

print("処理を開始します。Ctrl+Cで中断できます。")
processor.process_data()

print("\n全ての処理が完了しました。")
print(f"結果: {processor.results}")

保存された状態が見つかりません。最初から処理を開始します。
処理を開始します。Ctrl+Cで中断できます。
処理中: 50/100 完了^C
処理を中断します。状態を保存しています...
現在の状態を保存しました。

（プログラムを再度実行）

前回の状態を読み込みました。インデックス: 50
処理を開始します。Ctrl+Cで中断できます。
処理中: 100/100 完了
全ての処理が完了しました。
結果: [2, 4, 6, ..., 198, 200]