Python演算子の基礎｜四則演算から論理演算まで完全解説

Python演算子でつまずいていませんか？

みなさん、Python学習を始めて「演算子がたくさんあって覚えられない」と感じたことはありませんか？

「基本的な計算はできるけど、比較や論理演算が分からない」 「演算子の優先順位がごちゃごちゃになる」 「実際のプログラムでどう使うの？」

このような悩みを抱えたことはありませんか？

実は、Python演算子は分類と使い場面を理解すれば、とても簡単なんです。

この記事では、Python初心者の方向けに演算子の基礎から応用まで、具体的なコード例とともに詳しく解説します。 四則演算から論理演算まで、実際のプログラムで活用できる知識を身につけて、Python演算子をマスターしましょう！

Python演算子の全体像って？

まず、Python演算子の種類と分類を理解しましょう。

これを把握すると、どの演算子をいつ使うのかが明確になります。

演算子の分類

Pythonの主要な演算子

# 演算子の分類
operators_classification = {
    "算術演算子": ["+", "-", "*", "/", "//", "%", "**"],
    "代入演算子": ["=", "+=", "-=", "*=", "/=", "//=", "%=", "**="],
    "比較演算子": ["==", "!=", "<", ">", "<=", ">="],
    "論理演算子": ["and", "or", "not"],
    "ビット演算子": ["&", "|", "^", "~", "<<", ">>"],
    "メンバーシップ演算子": ["in", "not in"],
    "同一性演算子": ["is", "is not"]
}

# 各分類の説明
for category, operators in operators_classification.items():
    print(f"{category}: {', '.join(operators)}")

この分類を見ると、演算子は7つのカテゴリに分かれています。 算術演算子が数値計算、比較演算子が条件判定、論理演算子が複数条件の組み合わせを担当します。

実行結果：

算術演算子: +, -, *, /, //, %, ** 代入演算子: =, +=, -=, *=, /=, //=, %=, **= 比較演算子: ==, !=, <, >, <=, >= 論理演算子: and, or, not ビット演算子: &, |, ^, ~, <<, >> メンバーシップ演算子: in, not in 同一性演算子: is, is not

このように、演算子は目的別に整理されています。

演算子の優先順位

優先順位表（高い順）

# 演算子の優先順位の例
def demonstrate_precedence():
    """演算子の優先順位を示す例"""
    
    # 1. 括弧が最優先
    result1 = (2 + 3) * 4  # 20
    result2 = 2 + 3 * 4    # 14
    
    # 2. 指数演算が乗除算より優先
    result3 = 2 ** 3 * 4   # 32 (2^3 * 4)
    result4 = 2 * 3 ** 4   # 162 (2 * 3^4)
    
    # 3. 比較演算子の優先順位
    result5 = 5 + 3 > 2 * 3  # True (8 > 6)
    
    print(f"(2 + 3) * 4 = {result1}")
    print(f"2 + 3 * 4 = {result2}")
    print(f"2 ** 3 * 4 = {result3}")
    print(f"2 * 3 ** 4 = {result4}")
    print(f"5 + 3 > 2 * 3 = {result5}")

demonstrate_precedence()

この例では、括弧が最優先で処理されることがわかります。 指数演算（）**が乗除算よりも先に実行されます。

実行結果：

(2 + 3) * 4 = 20 2 + 3 * 4 = 14 2 ** 3 * 4 = 32 2 * 3 ** 4 = 162 5 + 3 > 2 * 3 = True

優先順位を覚えるよりも、括弧を使って明確にする方が安全です。

算術演算子の完全解説

数値計算で使用する基本的な演算子について学びましょう。

理解すると、Pythonでの計算処理がスムーズになります。

基本的な四則演算

加算、減算、乗算、除算

# 基本的な四則演算
def basic_arithmetic():
    """基本的な四則演算の例"""
    a = 10
    b = 3
    
    # 加算
    addition = a + b
    print(f"{a} + {b} = {addition}")
    
    # 減算
    subtraction = a - b
    print(f"{a} - {b} = {subtraction}")
    
    # 乗算
    multiplication = a * b
    print(f"{a} * {b} = {multiplication}")
    
    # 除算（浮動小数点）
    division = a / b
    print(f"{a} / {b} = {division}")
    
    # 除算の結果は常にfloat型
    print(f"10 / 2 = {10 / 2} (型: {type(10 / 2)})")

basic_arithmetic()

このコードでは、四則演算の基本的な動作を示しています。 除算（/）の結果は常にfloat型になることが重要なポイントです。

実行結果：

10 + 3 = 13 10 - 3 = 7 10 * 3 = 30 10 / 3 = 3.3333333333333335 10 / 2 = 5.0 (型: <class 'float'>)

整数同士の割り算でも、結果はfloat型になります。

特殊な算術演算子

整数除算、剰余、べき乗

# 特殊な算術演算子
def special_arithmetic():
    """特殊な算術演算子の例"""
    a = 17
    b = 5
    
    # 整数除算（切り捨て除算）
    floor_division = a // b
    print(f"{a} // {b} = {floor_division}")
    
    # 剰余（余り）
    modulo = a % b
    print(f"{a} % {b} = {modulo}")
    
    # べき乗
    power = a ** b
    print(f"{a} ** {b} = {power}")
    
    # 負の数での整数除算
    negative_division = -17 // 5
    print(f"-17 // 5 = {negative_division}")
    
    # 浮動小数点数での演算
    float_division = 17.5 // 5
    print(f"17.5 // 5 = {float_division}")

special_arithmetic()

ここでは、**整数除算（//）**が小数点以下を切り捨てることを示しています。 **剰余（%）**は割り算の余りを返します。

実行結果：

17 // 5 = 3 17 % 5 = 2 17 ** 5 = 1419857 -17 // 5 = -4 17.5 // 5 = 3.0

負の数の整数除算では、結果が負の無限大方向に丸められます。

実践的な算術演算の活用

日常的な計算問題

# 実践的な算術演算の例
def practical_arithmetic():
    """実践的な算術演算の活用例"""
    
    # 1. 割り勘計算
    def calculate_split_bill(total_amount, num_people):
        """割り勘の計算"""
        per_person = total_amount // num_people
        remainder = total_amount % num_people
        
        return per_person, remainder
    
    bill = 1000
    people = 3
    per_person, remainder = calculate_split_bill(bill, people)
    print(f"合計{bill}円を{people}人で割り勘:")
    print(f"一人当たり: {per_person}円")
    print(f"余り: {remainder}円")
    
    # 2. 時間の計算
    def convert_seconds(total_seconds):
        """秒を時分秒に変換"""
        hours = total_seconds // 3600
        minutes = (total_seconds % 3600) // 60
        seconds = total_seconds % 60
        
        return hours, minutes, seconds
    
    total_sec = 3725
    h, m, s = convert_seconds(total_sec)
    print(f"
{total_sec}秒は {h}時間{m}分{s}秒です")
    
    # 3. 複利計算
    def compound_interest(principal, rate, time):
        """複利計算"""
        amount = principal * (1 + rate) ** time
        interest = amount - principal
        
        return amount, interest
    
    principal = 100000  # 元金
    rate = 0.05         # 年利5%
    time = 10           # 10年
    
    amount, interest = compound_interest(principal, rate, time)
    print(f"
元金: {principal:,}円")
    print(f"10年後の金額: {amount:,.0f}円")
    print(f"利息: {interest:,.0f}円")

practical_arithmetic()

これらの例では、実際の生活で使える計算を示しています。 **整数除算（//）と剰余（%）**を組み合わせて、単位の変換や分割計算が行えます。

実行結果：

合計1000円を3人で割り勘: 一人当たり: 333円 余り: 1円 3725秒は 1時間2分5秒です 元金: 100,000円 10年後の金額: 162,889円 利息: 62,889円

このように、算術演算子を組み合わせることで複雑な計算も簡単に行えます。

代入演算子の活用

変数への値の代入を効率的に行う演算子について学びましょう。

これを理解すると、コードがより簡潔で読みやすくなります。

基本的な代入演算子

通常の代入と複合代入

# 基本的な代入演算子
def assignment_operators():
    """代入演算子の例"""
    
    # 通常の代入
    x = 10
    print(f"x = {x}")
    
    # 複合代入演算子
    x += 5    # x = x + 5 と同じ
    print(f"x += 5 → x = {x}")
    
    x -= 3    # x = x - 3 と同じ
    print(f"x -= 3 → x = {x}")
    
    x *= 2    # x = x * 2 と同じ
    print(f"x *= 2 → x = {x}")
    
    x /= 4    # x = x / 4 と同じ
    print(f"x /= 4 → x = {x}")
    
    x //= 2   # x = x // 2 と同じ
    print(f"x //= 2 → x = {x}")
    
    x %= 3    # x = x % 3 と同じ
    print(f"x %= 3 → x = {x}")
    
    x **= 3   # x = x ** 3 と同じ
    print(f"x **= 3 → x = {x}")

assignment_operators()

複合代入演算子は、変数の値を更新する際に便利です。 **+=、-=、*=、/=**などを使うことで、コードが簡潔になります。

実行結果：

x = 10 x += 5 → x = 15 x -= 3 → x = 12 x *= 2 → x = 24 x /= 4 → x = 6.0 x //= 2 → x = 3.0 x %= 3 → x = 0.0 x **= 3 → x = 0.0

複合代入演算子を使うことで、同じ変数を2回書く必要がなくなります。

複数変数の代入

一度に複数の変数に代入

# 複数変数の代入
def multiple_assignment():
    """複数変数の代入例"""
    
    # 複数の変数に同じ値を代入
    a = b = c = 0
    print(f"a={a}, b={b}, c={c}")
    
    # 複数の変数に異なる値を代入
    x, y, z = 1, 2, 3
    print(f"x={x}, y={y}, z={z}")
    
    # リストからの代入
    numbers = [10, 20, 30]
    first, second, third = numbers
    print(f"first={first}, second={second}, third={third}")
    
    # 変数の値を交換
    a, b = 100, 200
    print(f"交換前: a={a}, b={b}")
    
    a, b = b, a  # Pythonらしい書き方
    print(f"交換後: a={a}, b={b}")
    
    # アンパック代入
    data = [1, 2, 3, 4, 5]
    first, second, *rest = data
    print(f"first={first}, second={second}, rest={rest}")

multiple_assignment()

Pythonの多重代入は、複数の変数を一度に扱えて便利です。 変数の交換も、一時変数を使わずに簡単に行えます。

実行結果：

a=0, b=0, c=0 x=1, y=2, z=3 first=10, second=20, third=30 交換前: a=100, b=200 交換後: a=200, b=100 first=1, second=2, rest=[3, 4, 5]

アンパック代入を使うと、リストの一部を別の変数に分けて代入できます。

実践的な代入演算子の活用

カウンターと累積計算

# 実践的な代入演算子の活用
def practical_assignment():
    """実践的な代入演算子の例"""
    
    # 1. カウンターの実装
    def count_characters(text):
        """文字数をカウント"""
        vowel_count = 0
        consonant_count = 0
        
        for char in text.lower():
            if char.isalpha():
                if char in 'aeiou':
                    vowel_count += 1
                else:
                    consonant_count += 1
        
        return vowel_count, consonant_count
    
    text = "Hello Python"
    vowels, consonants = count_characters(text)
    print(f"'{text}' の母音: {vowels}個, 子音: {consonants}個")
    
    # 2. 累積計算
    def calculate_running_average(numbers):
        """逐次平均を計算"""
        total = 0
        count = 0
        averages = []
        
        for num in numbers:
            total += num
            count += 1
            averages.append(total / count)
        
        return averages
    
    numbers = [10, 20, 30, 40, 50]
    running_avg = calculate_running_average(numbers)
    
    print(f"
数値: {numbers}")
    print(f"逐次平均: {running_avg}")
    
    # 3. 文字列の構築
    def build_message(items):
        """メッセージの構築"""
        message = "買い物リスト: "
        
        for i, item in enumerate(items):
            if i > 0:
                message += ", "
            message += item
        
        return message
    
    shopping_list = ["りんご", "バナナ", "オレンジ"]
    message = build_message(shopping_list)
    print(f"
{message}")

practical_assignment()

これらの例では、+=演算子を使ったカウンターと累積計算を示しています。 文字列の構築でも、+=演算子が活用されています。

実行結果：

'Hello Python' の母音: 4個, 子音: 7個 数値: [10, 20, 30, 40, 50] 逐次平均: [10.0, 15.0, 20.0, 25.0, 30.0] 買い物リスト: りんご, バナナ, オレンジ

代入演算子を組み合わせることで、効率的なデータ処理が可能になります。

比較演算子の完全理解

条件判定で使用する比較演算子について詳しく学びましょう。

これを理解すると、プログラムの条件分岐が正確にできます。

基本的な比較演算子

等しい、等しくない、大小関係

# 基本的な比較演算子
def comparison_operators():
    """比較演算子の例"""
    
    a = 10
    b = 5
    c = 10
    
    # 等しい
    print(f"{a} == {b}: {a == b}")
    print(f"{a} == {c}: {a == c}")
    
    # 等しくない
    print(f"{a} != {b}: {a != b}")
    print(f"{a} != {c}: {a != c}")
    
    # 大小関係
    print(f"{a} > {b}: {a > b}")
    print(f"{a} < {b}: {a < b}")
    print(f"{a} >= {c}: {a >= c}")
    print(f"{a} <= {c}: {a <= c}")
    
    # 文字列の比較
    str1 = "apple"
    str2 = "banana"
    print(f"
文字列比較:")
    print(f"'{str1}' < '{str2}': {str1 < str2}")
    print(f"'{str1}' == '{str1}': {str1 == str1}")

comparison_operators()

比較演算子は、TrueまたはFalseの値を返します。 文字列の比較では、辞書順（アルファベット順）で判定されます。

実行結果：

10 == 5: False 10 == 10: True 10 != 5: True 10 != 10: False 10 > 5: True 10 < 5: False 10 >= 10: True 10 <= 10: True 文字列比較: 'apple' < 'banana': True 'apple' == 'apple': True

**等しい（==）と等しくない（!=）**の違いを理解することが重要です。

異なるデータ型の比較

数値と文字列、リスト同士の比較

# 異なるデータ型の比較
def type_comparison():
    """異なるデータ型の比較例"""
    
    # 数値同士の比較
    int_num = 10
    float_num = 10.0
    print(f"int vs float: {int_num} == {float_num}: {int_num == float_num}")
    
    # 文字列の比較（辞書順）
    words = ["apple", "banana", "cherry"]
    print(f"
文字列の辞書順比較:")
    for i in range(len(words) - 1):
        result = words[i] < words[i + 1]
        print(f"'{words[i]}' < '{words[i + 1]}': {result}")
    
    # リストの比較
    list1 = [1, 2, 3]
    list2 = [1, 2, 3]
    list3 = [1, 2, 4]
    
    print(f"
リストの比較:")
    print(f"{list1} == {list2}: {list1 == list2}")
    print(f"{list1} == {list3}: {list1 == list3}")
    print(f"{list1} < {list3}: {list1 < list3}")
    
    # 文字列の長さ比較
    def compare_string_length(str1, str2):
        """文字列の長さを比較"""
        return len(str1) == len(str2)
    
    word1 = "Python"
    word2 = "Java"
    print(f"
'{word1}'と'{word2}'の長さは等しい: {compare_string_length(word1, word2)}")

type_comparison()

整数と浮動小数点数の比較では、値が同じなら等しいと判定されます。 リストの比較では、要素を順番に比較します。

実行結果：

int vs float: 10 == 10.0: True 文字列の辞書順比較: 'apple' < 'banana': True 'banana' < 'cherry': True リストの比較: [1, 2, 3] == [1, 2, 3]: True [1, 2, 3] == [1, 2, 4]: False [1, 2, 3] < [1, 2, 4]: True 'Python'と'Java'の長さは等しい: False

異なるデータ型でも、適切な比較が可能です。

実践的な比較演算子の活用

条件分岐での活用

# 実践的な比較演算子の活用
def practical_comparison():
    """実践的な比較演算子の例"""
    
    # 1. 成績評価システム
    def evaluate_grade(score):
        """成績を評価"""
        if score >= 90:
            return "A"
        elif score >= 80:
            return "B"
        elif score >= 70:
            return "C"
        elif score >= 60:
            return "D"
        else:
            return "F"
    
    scores = [95, 87, 73, 58, 42]
    print("成績評価:")
    for score in scores:
        grade = evaluate_grade(score)
        print(f"スコア {score}: {grade}")
    
    # 2. 年齢による分類
    def classify_age(age):
        """年齢による分類"""
        if age < 13:
            return "子供"
        elif age < 20:
            return "青年"
        elif age < 65:
            return "成人"
        else:
            return "シニア"
    
    ages = [8, 16, 25, 45, 70]
    print(f"
年齢分類:")
    for age in ages:
        category = classify_age(age)
        print(f"{age}歳: {category}")
    
    # 3. 価格比較システム
    def compare_prices(products):
        """価格比較"""
        if not products:
            return None
        
        cheapest = min(products, key=lambda x: x['price'])
        most_expensive = max(products, key=lambda x: x['price'])
        
        return cheapest, most_expensive
    
    products = [
        {"name": "商品A", "price": 1000},
        {"name": "商品B", "price": 1500},
        {"name": "商品C", "price": 800},
        {"name": "商品D", "price": 1200}
    ]
    
    cheapest, expensive = compare_prices(products)
    print(f"
最安値: {cheapest['name']} - {cheapest['price']}円")
    print(f"最高値: {expensive['name']} - {expensive['price']}円")

practical_comparison()

この例では、範囲による条件分岐を示しています。 比較演算子を連続して使用することで、複雑な条件判定が可能になります。

実行結果：

成績評価: スコア 95: A スコア 87: B スコア 73: C スコア 58: D スコア 42: F 年齢分類: 8歳: 子供 16歳: 青年 25歳: 成人 45歳: 成人 70歳: シニア 最安値: 商品C - 800円 最高値: 商品B - 1500円

比較演算子を組み合わせることで、実用的な判定システムが作れます。

論理演算子の完全マスター

複数の条件を組み合わせる論理演算子について詳しく学びましょう。

これを理解すると、複雑な条件判定が正確にできます。

基本的な論理演算子

and、or、not演算子

# 基本的な論理演算子
def logical_operators():
    """論理演算子の例"""
    
    # and演算子（両方がTrueの場合のみTrue）
    print("=== and演算子 ===")
    print(f"True and True: {True and True}")
    print(f"True and False: {True and False}")
    print(f"False and True: {False and True}")
    print(f"False and False: {False and False}")
    
    # or演算子（どちらかがTrueの場合True）
    print(f"
=== or演算子 ===")
    print(f"True or True: {True or True}")
    print(f"True or False: {True or False}")
    print(f"False or True: {False or True}")
    print(f"False or False: {False or False}")
    
    # not演算子（真偽を反転）
    print(f"
=== not演算子 ===")
    print(f"not True: {not True}")
    print(f"not False: {not False}")
    
    # 実際の条件での使用例
    age = 25
    has_license = True
    has_car = False
    
    print(f"
=== 実際の条件例 ===")
    print(f"年齢: {age}, 免許: {has_license}, 車: {has_car}")
    
    # 複数条件の組み合わせ
    can_drive = age >= 18 and has_license
    can_drive_own_car = can_drive and has_car
    needs_rental = can_drive and not has_car
    
    print(f"運転可能: {can_drive}")
    print(f"自家用車で運転可能: {can_drive_own_car}")
    print(f"レンタカーが必要: {needs_rental}")

logical_operators()

and演算子は、両方の条件がTrueの場合のみTrueを返します。 or演算子は、少なくとも一方がTrueの場合Trueを返します。

実行結果：

=== and演算子 === True and True: True True and False: False False and True: False False and False: False === or演算子 === True or True: True True or False: True False or True: True False or False: False === not演算子 === not True: False not False: True === 実際の条件例 === 年齢: 25, 免許: True, 車: False 運転可能: True 自家用車で運転可能: False レンタカーが必要: True

not演算子は、条件を反転させる際に使用します。

短絡評価（ショートサーキット）

効率的な条件判定

# 短絡評価の例
def short_circuit_evaluation():
    """短絡評価の例"""
    
    # and演算子の短絡評価
    def expensive_function():
        """時間のかかる関数（シミュレーション）"""
        print("時間のかかる処理を実行中...")
        return True
    
    # 最初の条件がFalseの場合、2番目の関数は実行されない
    condition1 = False
    print(f"条件1: {condition1}")
    result = condition1 and expensive_function()
    print(f"結果: {result}")
    print()
    
    # 最初の条件がTrueの場合、2番目の関数も実行される
    condition2 = True
    print(f"条件2: {condition2}")
    result = condition2 and expensive_function()
    print(f"結果: {result}")
    print()
    
    # or演算子の短絡評価
    # 最初の条件がTrueの場合、2番目の関数は実行されない
    condition3 = True
    print(f"条件3: {condition3}")
    result = condition3 or expensive_function()
    print(f"結果: {result}")
    print()
    
    # 安全な条件チェックの例
    def safe_division(a, b):
        """安全な除算（短絡評価を利用）"""
        if b != 0 and a / b > 1:
            return f"{a} / {b} = {a / b} (1より大きい)"
        else:
            return f"除算できないか、結果が1以下です"
    
    print(safe_division(10, 2))  # 正常な除算
    print(safe_division(10, 0))  # ゼロ除算を回避
    print(safe_division(2, 10))  # 結果が1以下

short_circuit_evaluation()

短絡評価とは、最初の条件だけで結果が決まる場合、2番目の条件を評価しない機能です。 and演算子では、最初がFalseなら2番目を評価しません。

実行結果：

条件1: False 結果: False 条件2: True 時間のかかる処理を実行中... 結果: True 条件3: True 結果: True 10 / 2 = 5.0 (1より大きい) 除算できないか、結果が1以下です 除算できないか、結果が1以下です

短絡評価を活用することで、効率的で安全な条件判定が可能になります。

複雑な論理条件

複数の条件を組み合わせた実例

# 複雑な論理条件の例
def complex_logical_conditions():
    """複雑な論理条件の例"""
    
    # 1. 学生の成績判定システム
    def evaluate_student(math_score, english_score, attendance_rate):
        """総合的な学生評価"""
        
        # 合格条件
        basic_pass = math_score >= 60 and english_score >= 60
        excellent = math_score >= 80 and english_score >= 80
        good_attendance = attendance_rate >= 0.8
        
        # 複合条件
        honor_student = excellent and good_attendance
        regular_pass = basic_pass and good_attendance
        conditional_pass = basic_pass and not good_attendance
        
        if honor_student:
            return "優秀学生"
        elif regular_pass:
            return "合格"
        elif conditional_pass:
            return "条件付き合格"
        else:
            return "不合格"
    
    # テストケース
    students = [
        {"name": "田中", "math": 85, "english": 90, "attendance": 0.95},
        {"name": "佐藤", "math": 75, "english": 70, "attendance": 0.85},
        {"name": "鈴木", "math": 65, "english": 68, "attendance": 0.70},
        {"name": "山田", "math": 50, "english": 55, "attendance": 0.60}
    ]
    
    print("学生評価結果:")
    for student in students:
        result = evaluate_student(
            student["math"], 
            student["english"], 
            student["attendance"]
        )
        print(f"{student['name']}: {result}")
    
    # 2. 商品推薦システム
    def recommend_product(age, gender, income, interests):
        """商品推薦システム"""
        
        # ターゲット条件
        young_male = age < 30 and gender == "男性"
        high_income = income > 50000
        tech_interested = "テクノロジー" in interests
        sports_interested = "スポーツ" in interests
        
        # 推薦ロジック
        if young_male and tech_interested:
            return "ゲーミング機器"
        elif high_income and sports_interested:
            return "プレミアムスポーツ用品"
        elif age > 50 and "健康" in interests:
            return "健康管理商品"
        elif young_male and sports_interested:
            return "スポーツウェア"
        else:
            return "一般商品"
    
    # 顧客データ
    customers = [
        {"name": "A", "age": 25, "gender": "男性", "income": 40000, "interests": ["テクノロジー", "ゲーム"]},
        {"name": "B", "age": 35, "gender": "女性", "income": 60000, "interests": ["スポーツ", "健康"]},
        {"name": "C", "age": 55, "gender": "男性", "income": 70000, "interests": ["健康", "読書"]},
        {"name": "D", "age": 22, "gender": "男性", "income": 30000, "interests": ["スポーツ", "音楽"]}
    ]
    
    print(f"
商品推薦結果:")
    for customer in customers:
        recommendation = recommend_product(
            customer["age"],
            customer["gender"],
            customer["income"],
            customer["interests"]
        )
        print(f"{customer['name']}: {recommendation}")

complex_logical_conditions()

この例では、複数の条件を組み合わせた複雑な判定を示しています。 and、or、not演算子を適切に使い分けることで、現実的な業務ロジックを表現できます。

実行結果：

学生評価結果: 田中: 優秀学生 佐藤: 合格 鈴木: 条件付き合格 山田: 不合格 商品推薦結果: A: ゲーミング機器 B: プレミアムスポーツ用品 C: 健康管理商品 D: スポーツウェア

複雑な論理条件を適切に組み合わせることで、実用的なシステムが構築できます。

その他の重要な演算子

Pythonの特徴的な演算子について学びましょう。

これらを理解すると、より効率的なプログラムが書けます。

メンバーシップ演算子

in、not in演算子

# メンバーシップ演算子
def membership_operators():
    """メンバーシップ演算子の例"""
    
    # リストでの使用
    fruits = ["apple", "banana", "orange", "grape"]
    print(f"果物リスト: {fruits}")
    print(f"'apple' in fruits: {'apple' in fruits}")
    print(f"'melon' in fruits: {'melon' in fruits}")
    print(f"'melon' not in fruits: {'melon' not in fruits}")
    
    # 文字列での使用
    text = "Python Programming"
    print(f"
文字列: '{text}'")
    print(f"'Python' in text: {'Python' in text}")
    print(f"'Java' in text: {'Java' in text}")
    print(f"'gram' in text: {'gram' in text}")
    
    # 辞書での使用
    student_grades = {"Alice": 85, "Bob": 92, "Charlie": 78}
    print(f"
成績辞書: {student_grades}")
    print(f"'Alice' in student_grades: {'Alice' in student_grades}")
    print(f"'David' in student_grades: {'David' in student_grades}")
    
    # 実践的な使用例
    def check_permission(user, allowed_users):
        """ユーザーの権限チェック"""
        if user in allowed_users:
            return f"{user}にはアクセス権限があります"
        else:
            return f"{user}にはアクセス権限がありません"
    
    allowed_users = ["admin", "manager", "user1", "user2"]
    test_users = ["admin", "user1", "guest"]
    
    print(f"
権限チェック:")
    for user in test_users:
        result = check_permission(user, allowed_users)
        print(result)

membership_operators()

in演算子は、要素がコレクションに含まれているかを確認します。 not in演算子は、要素が含まれていないかを確認します。

実行結果：

果物リスト: ['apple', 'banana', 'orange', 'grape'] 'apple' in fruits: True 'melon' in fruits: False 'melon' not in fruits: True 文字列: 'Python Programming' 'Python' in text: True 'Java' in text: False 'gram' in text: True 成績辞書: {'Alice': 85, 'Bob': 92, 'Charlie': 78} 'Alice' in student_grades: True 'David' in student_grades: False 権限チェック: adminにはアクセス権限があります user1にはアクセス権限があります guestにはアクセス権限がありません

メンバーシップ演算子は、要素の存在チェックでよく使われます。

同一性演算子

is、is not演算子

# 同一性演算子
def identity_operators():
    """同一性演算子の例"""
    
    # 基本的な使用
    a = [1, 2, 3]
    b = [1, 2, 3]
    c = a
    
    print(f"a = {a}")
    print(f"b = {b}")
    print(f"c = a")
    
    # == と is の違い
    print(f"
== vs is の違い:")
    print(f"a == b: {a == b}")  # 値が同じ
    print(f"a is b: {a is b}")  # 同じオブジェクトではない
    print(f"a is c: {a is c}")  # 同じオブジェクト
    
    # オブジェクトのIDを確認
    print(f"
オブジェクトID:")
    print(f"id(a): {id(a)}")
    print(f"id(b): {id(b)}")
    print(f"id(c): {id(c)}")
    
    # Noneとの比較
    value = None
    print(f"
Noneとの比較:")
    print(f"value is None: {value is None}")
    print(f"value == None: {value == None}")
    
    # 小さな整数の特殊な挙動
    x = 100
    y = 100
    print(f"
小さな整数の比較:")
    print(f"x = {x}, y = {y}")
    print(f"x is y: {x is y}")  # 小さな整数は同じオブジェクト
    
    # 大きな整数の場合
    big_x = 1000
    big_y = 1000
    print(f"
大きな整数の比較:")
    print(f"big_x = {big_x}, big_y = {big_y}")
    print(f"big_x is big_y: {big_x is big_y}")  # 大きな整数は異なるオブジェクト

identity_operators()

is演算子は、同じオブジェクトかどうかを判定します。 ==演算子は、値が同じかどうかを判定します。

実行結果：

a = [1, 2, 3] b = [1, 2, 3] c = a == vs is の違い: a == b: True a is b: False a is c: True オブジェクトID: id(a): 140234567890816 id(b): 140234567890752 id(c): 140234567890816 Noneとの比較: value is None: True value == None: True 小さな整数の比較: x = 100, y = 100 x is y: True 大きな整数の比較: big_x = 1000, big_y = 1000 big_x is big_y: False

Noneとの比較では、is演算子を使うのが推奨されます。

演算子の実践的な活用例

実際のプログラムでの演算子の使い方を学びましょう。

これを理解すると、現実的な問題解決ができます。

条件付きプログラムの作成

複数の演算子を組み合わせた実例

# 実践的な演算子の活用例
def practical_operator_usage():
    """実践的な演算子の活用例"""
    
    # 1. 会員制度システム
    class MembershipSystem:
        def __init__(self):
            self.premium_members = ["alice", "bob", "charlie"]
            self.blocked_users = ["spam_user", "banned_user"]
        
        def check_access(self, username, age, purchase_amount):
            """アクセス権限のチェック"""
            
            # 基本的な条件
            is_adult = age >= 18
            is_premium = username in self.premium_members
            is_blocked = username in self.blocked_users
            has_purchase = purchase_amount > 0
            is_big_spender = purchase_amount >= 10000
            
            # 複合条件
            basic_access = is_adult and not is_blocked
            premium_access = basic_access and is_premium
            vip_access = premium_access and is_big_spender
            
            if is_blocked:
                return "アクセス拒否: ブロックされています"
            elif not is_adult:
                return "アクセス拒否: 年齢制限"
            elif vip_access:
                return "VIPアクセス: 全機能利用可能"
            elif premium_access:
                return "プレミアムアクセス: 拡張機能利用可能"
            elif basic_access:
                return "基本アクセス: 標準機能利用可能"
            else:
                return "アクセス拒否: 条件未満"
        
        def calculate_discount(self, username, purchase_amount):
            """割引計算"""
            base_discount = 0
            
            # 会員ステータスによる割引
            if username in self.premium_members:
                base_discount += 0.1  # 10%割引
            
            # 購入金額による割引
            if purchase_amount >= 50000:
                base_discount += 0.15  # 15%追加割引
            elif purchase_amount >= 20000:
                base_discount += 0.10  # 10%追加割引
            elif purchase_amount >= 10000:
                base_discount += 0.05  # 5%追加割引
            
            # 最大割引率の制限
            final_discount = min(base_discount, 0.3)  # 最大30%
            discount_amount = purchase_amount * final_discount
            final_amount = purchase_amount - discount_amount
            
            return final_amount, discount_amount, final_discount
    
    # テストケース
    system = MembershipSystem()
    test_users = [
        {"name": "alice", "age": 25, "purchase": 15000},
        {"name": "bob", "age": 30, "purchase": 25000},
        {"name": "charlie", "age": 35, "purchase": 60000},
        {"name": "david", "age": 16, "purchase": 5000},
        {"name": "spam_user", "age": 25, "purchase": 10000}
    ]
    
    print("会員制度システムのテスト:")
    for user in test_users:
        access_result = system.check_access(
            user["name"], user["age"], user["purchase"]
        )
        print(f"{user['name']}: {access_result}")
        
        if "アクセス拒否" not in access_result:
            final_amount, discount_amount, discount_rate = system.calculate_discount(
                user["name"], user["purchase"]
            )
            print(f"  購入金額: {user['purchase']:,}円")
            print(f"  割引額: {discount_amount:,.0f}円 ({discount_rate:.1%})")
            print(f"  最終金額: {final_amount:,.0f}円")
        print()

practical_operator_usage()

この例では、複数の演算子を組み合わせた複雑なシステムを示しています。 メンバーシップ演算子、比較演算子、論理演算子を適切に使い分けることで、実用的な業務ロジックを実装できます。

実行結果：

会員制度システムのテスト: alice: プレミアムアクセス: 拡張機能利用可能 購入金額: 15,000円 割引額: 2,250円 (15.0%) 最終金額: 12,750円 bob: VIPアクセス: 全機能利用可能 購入金額: 25,000円 割引額: 5,000円 (20.0%) 最終金額: 20,000円 charlie: VIPアクセス: 全機能利用可能 購入金額: 60,000円 割引額: 15,000円 (25.0%) 最終金額: 45,000円 david: アクセス拒否: 年齢制限 spam_user: アクセス拒否: ブロックされています

様々な演算子を組み合わせることで、現実的なビジネスロジックを表現できます。

データ処理での演算子活用

リストやデータの処理

# データ処理での演算子活用
def data_processing_with_operators():
    """データ処理での演算子活用例"""
    
    # サンプルデータ
    sales_data = [
        {"product": "商品A", "price": 1000, "quantity": 10, "category": "電子機器"},
        {"product": "商品B", "price": 2000, "quantity": 5, "category": "電子機器"},
        {"product": "商品C", "price": 500, "quantity": 20, "category": "日用品"},
        {"product": "商品D", "price": 1500, "quantity": 8, "category": "電子機器"},
        {"product": "商品E", "price": 800, "quantity": 15, "category": "日用品"}
    ]
    
    # 1. 条件に基づくデータフィルタリング
    def filter_sales_data(data, min_price=0, max_price=float('inf'), category=None):
        """売上データのフィルタリング"""
        filtered = []
        
        for item in data:
            # 価格条件
            price_condition = min_price <= item["price"] <= max_price
            
            # カテゴリ条件
            category_condition = category is None or item["category"] == category
            
            # 在庫条件
            stock_condition = item["quantity"] > 0
            
            # 全条件を満たす場合のみ追加
            if price_condition and category_condition and stock_condition:
                filtered.append(item)
        
        return filtered
    
    # フィルタリングの実行
    expensive_electronics = filter_sales_data(
        sales_data, 
        min_price=1500, 
        category="電子機器"
    )
    
    print("高価な電子機器:")
    for item in expensive_electronics:
        print(f"  {item['product']}: {item['price']:,}円")
    
    # 2. 売上の統計計算
    def calculate_sales_statistics(data):
        """売上統計の計算"""
        if not data:
            return None
        
        total_revenue = 0
        total_quantity = 0
        categories = set()
        
        for item in data:
            revenue = item["price"] * item["quantity"]
            total_revenue += revenue
            total_quantity += item["quantity"]
            categories.add(item["category"])
        
        average_price = total_revenue / total_quantity if total_quantity > 0 else 0
        
        return {
            "total_revenue": total_revenue,
            "total_quantity": total_quantity,
            "average_price": average_price,
            "categories": list(categories),
            "category_count": len(categories)
        }
    
    # 統計計算の実行
    stats = calculate_sales_statistics(sales_data)
    print(f"
売上統計:")
    print(f"  総売上: {stats['total_revenue']:,}円")
    print(f"  総販売数: {stats['total_quantity']:,}個")
    print(f"  平均単価: {stats['average_price']:,.0f}円")
    print(f"  カテゴリ数: {stats['category_count']}種類")
    print(f"  カテゴリ: {', '.join(stats['categories'])}")
    
    # 3. 条件に基づく価格調整
    def adjust_prices(data, electronics_discount=0.1, bulk_discount_threshold=10):
        """価格調整"""
        adjusted_data = []
        
        for item in data.copy():
            new_item = item.copy()
            original_price = item["price"]
            
            # 電子機器の割引
            if item["category"] == "電子機器":
                new_item["price"] *= (1 - electronics_discount)
            
            # 大量購入割引
            if item["quantity"] >= bulk_discount_threshold:
                new_item["price"] *= 0.95  # 5%追加割引
            
            # 割引額の計算
            discount_amount = original_price - new_item["price"]
            new_item["discount"] = discount_amount
            
            adjusted_data.append(new_item)
        
        return adjusted_data
    
    # 価格調整の実行
    adjusted_data = adjust_prices(sales_data)
    print(f"
価格調整後:")
    for item in adjusted_data:
        if item["discount"] > 0:
            print(f"  {item['product']}: {item['price']:,.0f}円 (割引: {item['discount']:,.0f}円)")
        else:
            print(f"  {item['product']}: {item['price']:,.0f}円 (割引なし)")

data_processing_with_operators()

この例では、演算子を活用したデータ処理を示しています。 比較演算子、論理演算子、算術演算子を組み合わせることで、効率的なデータ分析が可能になります。

実行結果：

高価な電子機器: 商品B: 2,000円 商品D: 1,500円 売上統計: 総売上: 67,000円 総販売数: 58個 平均単価: 1,155円 カテゴリ数: 2種類 カテゴリ: 電子機器, 日用品 価格調整後: 商品A: 855円 (割引: 145円) 商品B: 1,800円 (割引: 200円) 商品C: 475円 (割引: 25円) 商品D: 1,350円 (割引: 150円) 商品E: 760円 (割引: 40円)

演算子を適切に組み合わせることで、複雑なデータ処理も効率的に行えます。

まとめ：Python演算子の完全活用

Python演算子の要点をまとめます。

演算子別の重要ポイント

算術演算子

• 四則演算の基本と特殊演算（//、%、**）
• 浮動小数点と整数の演算の違い
• 実用的な計算での活用方法

代入演算子

• 複合代入による効率的なコード
• 複数変数の代入とアンパック
• カウンターや累積計算での活用

比較演算子

• 等価性と大小関係の判定
• 異なるデータ型での比較
• 条件分岐での実践的な活用

論理演算子

• and、or、notの基本概念
• 短絡評価による効率化
• 複雑な条件の組み合わせ

その他の演算子

• メンバーシップ演算子（in、not in）
• 同一性演算子（is、is not）
• 実際のプログラムでの使い分け

実践的な活用のコツ

可読性の向上

• 複雑な条件は括弧で明確化
• 適切な変数名で意図を表現
• コメントで条件の説明を追加

効率的なコード

• 短絡評価を活用した最適化
• 適切な演算子の選択
• 不要な計算の回避

エラーの防止

• 型の違いを意識した比較
• ゼロ除算などの例外処理
• 境界値での動作確認

Python演算子を正しく理解し活用することで、より効率的で読みやすいプログラムを書けるようになります。

ぜひ、この記事で学んだ知識を実際のプログラミングで活用してください。 演算子をマスターして、Python開発をより楽しみましょう！