Pythonicなコードの書き方

# リスト内包表記を使わないコード
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = []
for num in numbers:
    if num % 2 == 0:
        even_numbers.append(num)
print(even_numbers)  # [2, 4, 6]

# リスト内包表記を使ったコード
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = [num for num in numbers if num % 2 == 0]
print(even_numbers)  # [2, 4, 6]

# with文を使わないコード
file = None
try:
    file = open('example.txt', 'r')
    content_without = file.read()
    print(content_without)
except Exception as e:
    print(f"An error occurred: {e}")
finally:
    if file:
        file.close()

# with文を使ったコード
try:
    with open('example.txt', 'r') as file:
        content_with = file.read()
    print(content_with)
except Exception as e:
    print(f"An error occurred: {e}")

# 関数のデフォルト引数を使用しない場合
def log_message_without_default(message, prefix):
    print(f"{prefix} {message}")

log_message_without_default('This is a test message.', 'INFO:')
# INFO: This is a test message.

log_message_without_default('This is another test message.', 'WARNING:')
# WARNING: This is another test message.

# 関数のデフォルト引数を使用する場合
def log_message_with_default(message, prefix='INFO:'):
    print(f"{prefix} {message}")

log_message_with_default('This is a test message.')
# INFO: This is a test message.

log_message_with_default('This is another test message.', 'WARNING:')
# WARNING: This is another test message.

def add_numbers(a, b, c):
    return a + b + c

args = [1, 2, 3]

print("アンパック演算子を活用しない:", add_numbers(args[0], args[1], args[2]))
# アンパック演算子を活用しない:6

print("アンパック演算子を活用:", add_numbers(*args)) 
# アンパック演算子を活用:6

list_one = [1, 2, 3]
list_two = [4, 5, 6]

combined_list_without_unpack = list_one + list_two
print("アンパック演算子を活用しないリストの結合:", combined_list_without_unpack)
# アンパック演算子を活用しないリストの結合:[1, 2, 3, 4, 5, 6]

combined_list_with_unpack = [*list_one, *list_two]
print("アンパック演算子を活用したリストの結合:", combined_list_with_unpack)
# アンパック演算子を活用したリストの結合:[1, 2, 3, 4, 5, 6]

dict_one = {'a': 1, 'b': 2}
dict_two = {'c': 3, 'd': 4}

# Python 3.5+ では辞書のマージに別の直接的な方法はないため、update メソッドを使用
merged_dict_without_unpack = dict_one.copy()
merged_dict_without_unpack.update(dict_two)
print("アンパック演算子を活用しない辞書のマージ:", merged_dict_without_unpack)
# アンパック演算子を活用しない辞書のマージ:{'a': 1, 'b': 2, 'c': 3, 'd': 4}

# アンパック演算子を活用した場合
merged_dict_with_unpack = {**dict_one, **dict_two}
print("アンパック演算子を活用した辞書のマージ:", merged_dict_with_unpack)
# アンパック演算子を活用した辞書のマージ:{'a': 1, 'b': 2, 'c': 3, 'd': 4}

name = "Alice"
age = 30

# %フォーマットを使用する場合
greeting_with_percent = "Hello, %s. You are %d years old." % (name, age)
print("%フォーマットを使用:", greeting_with_percent)

# str.format()を使用する場合
greeting_with_str_format = "Hello, {}. You are {} years old.".format(name, age)
print("str.format()を使用:", greeting_with_str_format)

# f-stringsを使用する場合
greeting_with_fstrings = f"Hello, {name}. You are {age} years old."
print("f-stringsを使用:", greeting_with_fstrings)

# 状態を定数で管理する
IDLE = 1
RUNNING = 2
FINISHED = 3

current_state = IDLE
print(current_state)  # 1 を出力

# 状態をEnumで管理する
from enum import Enum, auto

class State(Enum):
    IDLE = auto()
    RUNNING = auto()
    FINISHED = auto()

current_state = State.IDLE
print(current_state)  # State.IDLE

# データクラスを使用しない場合
class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def __repr__(self):
        return f"Product(name='{self.name}', price={self.price})"

product = Product('Apple', 0.99)
print(product)  # Product(name='Apple', price=0.99)

# データクラスを使用した場合
from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float

product = Product('Apple', 0.99)
print(product)  # Product(name='Apple', price=0.99)

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

美しさは醜さよりも優れている。
明示は暗示よりも優れている。
単純さは複雑さよりも優れている。
複雑さは難解さよりも優れている。
平らな構造はネストした構造よりも優れている。
密集するよりも、空間を空けるほうが読みやすい。
可読性は重要だ。
特別な場合も普遍的な原則に従うべきだ（ただし、実用性は純粋さに勝る）。
エラーは無視されるべきではない。
明確に間違っていることを黙認するより、エラーを明示的にするほうが良い。
あいまいさに直面したら、その解釈を推測することを拒むべきだ。
ただし、その一つの--そしてできればただ一つの--明らかな方法があるべきだ。
今はその方法が思いつかなくても、それがあるべきだ。
仕事をするには、一つの方法が最も良い場合もある。
今すぐ実装するよりも、まずは良いアイデアがあるかを考えるべきだ。
実装が難しいなら、それは良いアイデアではない。
実装が簡単なら、それは良いアイデアかもしれない。
名前空間は素晴らしいアイデアだ。もっとたくさん使うべきだ。