Summary  
This chapter explains how Python evaluates logical operators according to their precedence (not > and > or) and shows how using parentheses can override the default order of evaluation.  

General domain of usage  
Fitness tracking applications

Pythonアプリケーションを開発する際には、Pythonがどのように演算子の優先順位を処理するかを理解することが重要です。演算子の優先順位は、式内で演算が実行される順序を決定し、条件が正しく評価されることを保証します。かっこを使用することで、演算の順序を明確にし、制御することもできます。

### 論理演算子の優先順位
論理演算子の中で、Pythonは次の優先順位に従います:

#### 例：フィットネストラッカーの目標
フィットネストラッカーの文脈で例を用いて説明します:

# Example 1: AND has higher precedence than OR
steps_taken = 8000
step_goal = 10000
calories_burned = 450
calorie_goal = 500

first_result = steps_taken >= step_goal or calories_burned >= calorie_goal and False
# Same as: steps_taken >= step_goal or (calories_burned >= calorie_goal and False)

# Example 2: Parentheses change the precedence
second_result = (steps_taken >= step_goal or calories_burned >= calorie_goal) and True

# Example 3: NOT has the highest precedence
third_result = not (steps_taken >= step_goal) or calories_burned >= calorie_goal
# Same as: (not (steps_taken >= step_goal)) or (calories_burned >= calorie_goal)

print('The first expression is:', first_result)
print('The second expression is:', second_result)
print('The third expression is:', third_result)

論理演算子と同様に、**比較演算子**（`>=`、`<=`、`==` など）や**算術演算子**（`+`、`-`、`*`、`/` など）も特定の優先順位に従います。

例：
1. `*` や `/` などの算術演算子は、`+` や `-` よりも高い優先順位を持ちます；
2. 比較演算子（`<`、`>`、`==` など）は、算術演算の後に評価されます；
3. 論理演算子（<code>not</code>、<code>and</code>、<code>or</code>）は最後に評価されます。</br></br>

括弧 <code>( )</code> を使用することで、式の評価順序を明確にし、制御することができます。

注意

import unittest
from contextlib import redirect_stdout
import io
import importlib
import user_code
import ast

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_if_statement_is_single(self):
        with open("user_code.py", "r") as f:
            tree = ast.parse(f.read())

        # Count all If statements in the AST
        if_statements = [node for node in ast.walk(tree) if isinstance(node, ast.If)]

        # Check if any If statement contains another If inside it (nested If)
        nested_if_found = any(
            any(isinstance(child, ast.If) for child in ast.iter_child_nodes(if_node))
            for if_node in if_statements
        )

        _dynamic_test(
            self,
            len(if_statements) == 1 and not nested_if_found,
            "The solution correctly uses a single `if` statement without unnecessary nesting.",
            "The solution should contain only one `if` statement without nested conditions. Nested `if` statements make the code unnecessarily complex."
        )

    def test_variables_declared(self):
        """Check if all required variables are declared."""
        variables = ['steps_taken', 'step_goal', 'calories_burned', 'calorie_goal', 'morning_exercise', 'all_conditions_met']
        missing_vars = [var for var in variables if not hasattr(user_code, var)]
        
        _dynamic_test(
            self,
            not missing_vars,
            "All required variables are declared.",
            f"Missing variable(s): {', '.join(missing_vars)}."
        )

    def test_variables_types(self):
        """Check if each variable has the correct data type."""
        expected_types = {
            'steps_taken': int,
            'step_goal': int,
            'calories_burned': int,
            'calorie_goal': int,
            'morning_exercise': bool,
            'all_conditions_met': bool
        }

        for var_name, expected_type in expected_types.items():
            actual_value = getattr(user_code, var_name, None)
            actual_type = type(actual_value)

            _dynamic_test(
                self,
                isinstance(actual_value, expected_type),
                f"The `{var_name}` variable has the correct data type ({expected_type.__name__}).",
                f"Incorrect data type for `{var_name}`. Expected {expected_type.__name__}, but got {actual_type.__name__}."
            )


    def test_all_conditions_met_logic(self):
        """Check if `all_conditions_met` is correctly updated based on conditions."""
        # Extract values from user_code
        steps_taken = user_code.steps_taken
        step_goal = user_code.step_goal
        calories_burned = user_code.calories_burned
        calorie_goal = user_code.calorie_goal
        morning_exercise = user_code.morning_exercise

        # Expected logic
        expected_value = not (steps_taken <= step_goal and calories_burned <= calorie_goal and not morning_exercise)

        _dynamic_test(
            self,
            user_code.all_conditions_met == expected_value,
            f"The `all_conditions_met` variable is correctly set to {expected_value}.",
            f"Incorrect value for `all_conditions_met`. Expected {expected_value}, but got {user_code.all_conditions_met}."
        )

if __name__ == "__main__":
    unittest.main()


test_main.py

Pythonにおける条件分岐if-else演算子の微妙な違いを、明確な解説と実践的な例を通じて探求します。各概念を強化するハンズオン課題で理解を深め、より複雑な意思決定のためにif-elif-else文を効果的に使用する方法を学びます。

条件分岐のif演算子の多様性と、そのプログラム結果への影響力を理解します。論理演算子の世界を深く掘り下げ、実践的な活用方法を習得し、優先順位付けによって明確かつ効率的なコードを書く方法を学びます。

条件に基づいて意思決定を行う方法を学び、elseキーワードを使用してコードを簡素化し、効率性と可読性の両方を向上させます。三項演算子によるワンライナーでの意思決定の効率性を引き出します。

最も高度な条件文であるif-elif-elseについて学びます。その構文に慣れ、複数の意思決定シナリオをプログラムで正しく処理するための使い方を習得します。

Pythonにおける演算子の優先順位

論理演算子の優先順位

例：フィットネストラッカーの目標

解答