notebooks/1.5-python-basics-comparators-updated.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "acd0f8ed",
   "metadata": {},
   "source": [
    "# Python Comparisons and Logic: Making Decisions in Code\n",
    "\n",
    "In this lesson, we'll explore how Python handles logical operations and comparisons. We'll learn about boolean values, comparison operators, and how to combine conditions to make complex decisions in our code.\n",
    "\n",
    "## Boolean Values: True and False\n",
    "\n",
    "Let's start with the basics of boolean values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "61f9a494",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of boolean: <class 'bool'>\n",
      "Is Python fun? True\n",
      "Is coding hard? False\n"
     ]
    }
   ],
   "source": [
    "# Booleans are Python's way of representing True and False\n",
    "is_python_fun = True\n",
    "is_coding_hard = False\n",
    "\n",
    "print(f\"Type of boolean: {type(is_python_fun)}\")\n",
    "print(f\"Is Python fun? {is_python_fun}\")\n",
    "print(f\"Is coding hard? {is_coding_hard}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f14f22a",
   "metadata": {},
   "source": [
    "## Comparison Operators\n",
    "\n",
    "Python provides several operators for comparing values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "897cd537",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's look at various comparisons\n",
    "score = 85\n",
    "passing_grade = 70\n",
    "perfect_score = 100\n",
    "\n",
    "# Greater than and less than\n",
    "is_passing = score > passing_grade\n",
    "\n",
    "is_passing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "da0239e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_perfect = score >= perfect_score\n",
    "\n",
    "is_perfect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "03a9a9c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Equality comparisons\n",
    "is_exactly_passing = score == passing_grade  # Equality check\n",
    "\n",
    "is_exactly_passing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9e4e2aa3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "has_improved = score != passing_grade        # Inequality check\n",
    "\n",
    "has_improved"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "11ddcab8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Did I pass? True\n",
      "Did I get perfect? False\n",
      "Did I just barely pass? False\n",
      "Did I do better than passing? True\n"
     ]
    }
   ],
   "source": [
    "print(f\"Did I pass? {is_passing}\")\n",
    "print(f\"Did I get perfect? {is_perfect}\")\n",
    "print(f\"Did I just barely pass? {is_exactly_passing}\")\n",
    "print(f\"Did I do better than passing? {has_improved}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb1b38af",
   "metadata": {},
   "source": [
    "## Creating Complex Conditions\n",
    "\n",
    "We can combine conditions using `and` and `or`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "21320005",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cba71c63",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "25aa1e63",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ab5057a7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "13d55b42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Study Session Analysis:\n",
      "should_study: True\n",
      "time_is_good: True\n",
      "energy_is_good: True\n"
     ]
    }
   ],
   "source": [
    "def check_study_conditions(time_of_day, energy_level, is_weekend):\n",
    "    \"\"\"\n",
    "    Determine if it's a good time to study based on multiple factors\n",
    "    \"\"\"\n",
    "    # Check if it's an optimal time (between 9 AM and 8 PM)\n",
    "    good_time = time_of_day >= 9 and time_of_day <= 20\n",
    "    \n",
    "    # Check if energy levels are sufficient (scale of 1-10)\n",
    "    good_energy = energy_level >= 6\n",
    "    \n",
    "    # Determine if we should study\n",
    "    should_study = (good_time and good_energy) or is_weekend\n",
    "    \n",
    "    return {\n",
    "        \"should_study\": should_study,\n",
    "        \"time_is_good\": good_time,\n",
    "        \"energy_is_good\": good_energy\n",
    "    }\n",
    "\n",
    "# Test the function\n",
    "result = check_study_conditions(time_of_day=14, energy_level=8, is_weekend=False)\n",
    "print(\"Study Session Analysis:\")\n",
    "for condition, value in result.items():\n",
    "    print(f\"{condition}: {value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5383961a",
   "metadata": {},
   "source": [
    "## Practical Example: Task Priority System\n",
    "\n",
    "Here's a more complex example using comparisons and logic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2682ba01",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Task Analysis:\n",
      "\n",
      "Task: Client Presentation\n",
      "Priority: Critical\n",
      "Immediate Action: True\n",
      "Can Delegate: False\n",
      "\n",
      "Task: Email Responses\n",
      "Priority: High\n",
      "Immediate Action: False\n",
      "Can Delegate: False\n",
      "\n",
      "Task: Code Review\n",
      "Priority: Medium\n",
      "Immediate Action: False\n",
      "Can Delegate: False\n"
     ]
    }
   ],
   "source": [
    "def analyze_task(task_name, deadline_days, estimated_hours, importance):\n",
    "    \"\"\"\n",
    "    Analyze a task and determine its priority level and handling strategy\n",
    "    \"\"\"\n",
    "    is_urgent = deadline_days <= 3\n",
    "    is_big_task = estimated_hours > 4\n",
    "    is_important = importance >= 8  # Scale of 1-10\n",
    "    \n",
    "    # Determine priority level\n",
    "    if is_urgent and is_important:\n",
    "        priority = \"Critical\"\n",
    "    elif is_urgent or (is_important and is_big_task):\n",
    "        priority = \"High\"\n",
    "    elif is_important:\n",
    "        priority = \"Medium\"\n",
    "    else:\n",
    "        priority = \"Low\"\n",
    "    \n",
    "    # Determine handling strategy\n",
    "    needs_immediate_action = is_urgent and (is_important or is_big_task)\n",
    "    can_delegate = not is_important and is_big_task\n",
    "    \n",
    "    return {\n",
    "        \"task\": task_name,\n",
    "        \"priority\": priority,\n",
    "        \"needs_immediate_action\": needs_immediate_action,\n",
    "        \"can_delegate\": can_delegate\n",
    "    }\n",
    "\n",
    "# Test the system with different tasks\n",
    "tasks = [\n",
    "    {\"name\": \"Client Presentation\", \"deadline\": 2, \"hours\": 6, \"importance\": 9},\n",
    "    {\"name\": \"Email Responses\", \"deadline\": 1, \"hours\": 2, \"importance\": 5},\n",
    "    {\"name\": \"Code Review\", \"deadline\": 5, \"hours\": 3, \"importance\": 8}\n",
    "]\n",
    "\n",
    "print(\"Task Analysis:\")\n",
    "for task in tasks:\n",
    "    result = analyze_task(task[\"name\"], task[\"deadline\"], \n",
    "                         task[\"hours\"], task[\"importance\"])\n",
    "    print(f\"\\nTask: {result['task']}\")\n",
    "    print(f\"Priority: {result['priority']}\")\n",
    "    print(f\"Immediate Action: {result['needs_immediate_action']}\")\n",
    "    print(f\"Can Delegate: {result['can_delegate']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69dd4cbd",
   "metadata": {},
   "source": [
    "## Common Pitfalls and Tips\n",
    "\n",
    "Here are some important things to remember:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "da140c52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is the right way to compare!\n",
      "\n",
      "Boolean Operation Results:\n",
      "True and True = True\n",
      "True and False = False\n",
      "True or False = True\n",
      "False or False = False\n"
     ]
    }
   ],
   "source": [
    "# WRONG: Using assignment (=) instead of comparison (==)\n",
    "x = 5\n",
    "y = 5\n",
    "\n",
    "# This is incorrect and will cause an error:\n",
    "# if x = y:\n",
    "#     print(\"This won't work!\")\n",
    "\n",
    "# This is correct:\n",
    "if x == y:\n",
    "    print(\"This is the right way to compare!\")\n",
    "\n",
    "# Be careful with boolean operations\n",
    "print(\"\\nBoolean Operation Results:\")\n",
    "print(f\"True and True = {True and True}\")\n",
    "print(f\"True and False = {True and False}\")\n",
    "print(f\"True or False = {True or False}\")\n",
    "print(f\"False or False = {False or False}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "040bfe1a",
   "metadata": {},
   "source": [
    "## Key Takeaways\n",
    "\n",
    "- Boolean values (`True` and `False`) are fundamental for logical operations\n",
    "- Comparison operators (`>`, `<`, `>=`, `<=`, `==`, `!=`) return boolean values\n",
    "- `and` requires both conditions to be `True`\n",
    "- `or` requires at least one condition to be `True`\n",
    "- Use `==` for comparison and `=` for assignment\n",
    "- Complex conditions can be built by combining multiple comparisons\n",
    "- Always consider edge cases when working with logical operations\n",
    "\n",
    "In the next lesson, we'll explore how to use these concepts in if-statements and control flow!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "oreilly-automate-tasks",
   "language": "python",
   "name": "oreilly-automate-tasks"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}