chapter_5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='pyprog.png'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CHAPTER 5 SAMPLE PROGRAMS\n",
    "* Each cell has a Chapter 5 sample program.\n",
    "* Run each cell **as you read the textbook**.\n",
    "* **Experiment!** Edit cells and run them or insert new cells and run them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function_demo.py\n",
    "# This program demonstrates a function.\n",
    "# First, we define a function named message.\n",
    "def message():\n",
    "    print('I am Arthur')\n",
    "    print('King of the Britons')\n",
    "\n",
    "# Call the message function.\n",
    "message()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# two_functions.py\n",
    "# This program has two functions. First we\n",
    "# define the main function.\n",
    "def main():\n",
    "    print('I have a message for you.')\n",
    "    message()\n",
    "    print('Goodbye!')\n",
    "    \n",
    "# Next we define the message function.\n",
    "def message():\n",
    "    print('I am Arthur')\n",
    "    print('King of the Britons.')\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# acme_dryer.py\n",
    "# This program displays step-by-step instructions\n",
    "# for disassembling an Acme dryer.\n",
    "# The main function performs the program's main logic.\n",
    "def main():\n",
    "    # Display the start-up message.\n",
    "    startup_message()\n",
    "    input('Press Enter to see Step 1.')\n",
    "    # Display step 1.\n",
    "    step1()\n",
    "    input('Press Enter to see Step 2.')\n",
    "    # Display step 2.\n",
    "    step2()\n",
    "    input('Press Enter to see Step 3.')\n",
    "    # Display step 3.\n",
    "    step3()\n",
    "    input('Press Enter to see Step 4.')\n",
    "    # Display step 4.\n",
    "    step4()\n",
    "\n",
    "# The startup_message function displays the\n",
    "# program's initial message on the screen.\n",
    "def startup_message():\n",
    "    print('This program tells you how to')\n",
    "    print('disassemble an ACME laundry dryer.')\n",
    "    print('There are 4 steps in the process.')\n",
    "    print()\n",
    "\n",
    "# The step1 function displays the instructions\n",
    "# for step 1.\n",
    "def step1():\n",
    "    print('Step 1: Unplug the dryer and')\n",
    "    print('move it away from the wall.')\n",
    "    print()\n",
    "\n",
    "# The step2 function displays the instructions\n",
    "# for step 2.\n",
    "def step2():\n",
    "    print('Step 2: Remove the six screws')\n",
    "    print('from the back of the dryer.')\n",
    "    print()\n",
    "\n",
    "# The step3 function displays the instructions\n",
    "# for step 3.\n",
    "def step3():\n",
    "    print('Step 3: Remove the back panel')\n",
    "    print('from the dryer.')\n",
    "    print()\n",
    "\n",
    "# The step4 function displays the instructions\n",
    "# for step 4.\n",
    "def step4():\n",
    "    print('Step 4: Pull the top of the')\n",
    "    print('dryer straight up.')\n",
    "\n",
    "# Call the main function to begin the program.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bad_local.py\n",
    "# Definition of the main function.\n",
    "def main():\n",
    "    get_name()\n",
    "    print(f'Hello, {name}.')     # This causes an error!\n",
    "\n",
    "# Definition of the get_name function.\n",
    "def get_name():\n",
    "    name = input('Enter your name: ')\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# birds.py\n",
    "# This program demonstrates two functions that\n",
    "# have local variables with the same name.\n",
    "\n",
    "def main():\n",
    "    # Call the texas function.\n",
    "    texas()\n",
    "    # Call the california function.\n",
    "    california()\n",
    "\n",
    "# Definition of the texas function. It creates\n",
    "# a local variable named birds.\n",
    "def texas():\n",
    "    birds = 5000\n",
    "    print(f'texas has {birds} birds.')\n",
    "\n",
    "# Definition of the california function. It also\n",
    "# creates a local variable named birds.\n",
    "def california():\n",
    "    birds = 8000\n",
    "    print(f'california has {birds} birds.')\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pass_arg.py\n",
    "# This program demonstrates an argument being\n",
    "# passed to a function.\n",
    "\n",
    "def main():\n",
    "    value = 5\n",
    "    show_double(value)\n",
    "    \n",
    "# The show_double function accepts an argument\n",
    "# and displays double its value.\n",
    "def show_double(number):\n",
    "    result = number * 2\n",
    "    print(result)\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cups_to_ounces.py\n",
    "# This program converts cups to fluid ounces.\n",
    "\n",
    "def main():\n",
    "    # display the intro screen.\n",
    "    intro()\n",
    "    # Get the number of cups.\n",
    "    cups_needed = int(input('Enter the number of cups: '))\n",
    "    # Convert the cups to ounces.\n",
    "    cups_to_ounces(cups_needed)\n",
    "\n",
    "# The intro function displays an introductory screen.\n",
    "def intro():\n",
    "    print('This program converts measurements')\n",
    "    print('in cups to fluid ounces. For your')\n",
    "    print('reference the formula is:')\n",
    "    print('    1 cup = 8 fluid ounces')\n",
    "    print()\n",
    "\n",
    "# The cups_to_ounces function accepts a number of\n",
    "# cups and displays the equivalent number of ounces.\n",
    "def cups_to_ounces(cups):\n",
    "    ounces = cups * 8\n",
    "    print(f'That converts to {ounces} ounces.')\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiple_args.py\n",
    "# This program demonstrates a function that accepts\n",
    "# two arguments.\n",
    "\n",
    "def main():\n",
    "    print('The sum of 12 and 45 is')\n",
    "    show_sum(12, 45)\n",
    "\n",
    "# The show_sum function accepts two arguments\n",
    "# and displays their sum.\n",
    "def show_sum(num1, num2):\n",
    "    result = num1 + num2\n",
    "    print(result)\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# string_args.py\n",
    "# This program demonstrates passing two string\n",
    "# arguments to a function.\n",
    "\n",
    "def main():\n",
    "    first_name = input('Enter your first name: ')\n",
    "    last_name = input('Enter your last name: ')\n",
    "    print('Your name reversed is')\n",
    "    reverse_name(first_name, last_name)\n",
    "\n",
    "def reverse_name(first, last):\n",
    "    print(last, first)\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# change_me.py\n",
    "# This program demonstrates what happens when you\n",
    "# change the value of a parameter.\n",
    "\n",
    "def main():\n",
    "    value = 99\n",
    "    print('The value is', value)\n",
    "    change_me(value)\n",
    "    print(f'Back in main the value is {value}.')\n",
    "\n",
    "def change_me(arg):\n",
    "    print('I am changing the value.')\n",
    "    arg = 0\n",
    "    print(f'Now the value is {arg}.')\n",
    "\n",
    "# Call the main  function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# keyword_args.py\n",
    "# This program demonstrates keyword arguments.\n",
    "\n",
    "def main():\n",
    "    # Show the amount of simple interest using 0.01 as\n",
    "    # interest rate per period, 10 as the number of periods,\n",
    "    # and $10,000 as the principal.\n",
    "    show_interest(rate=0.01, periods=10, principal=10000.0)\n",
    "\n",
    "# The show_interest function displays the amount of\n",
    "# simple interest for a given principal, interest rate\n",
    "# per period, and number of periods.\n",
    "\n",
    "def show_interest(principal, rate, periods):\n",
    "    interest = principal * rate * periods\n",
    "    print(f'The simple interest will be ${interest:,.2f}.')\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# keyword_string_args.py\n",
    "# This program demonstrates passes two strings as\n",
    "# keyword arguments to a function.\n",
    "\n",
    "def main():\n",
    "    first_name = input('Enter your first name: ')\n",
    "    last_name = input('Enter your last name: ')\n",
    "    print('Your name reversed is')\n",
    "    reverse_name(last=last_name, first=first_name)\n",
    "\n",
    "def reverse_name(first, last):\n",
    "    print(last, first)\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# global1.py\n",
    "# Create a global variable.\n",
    "my_value = 10\n",
    "\n",
    "# The show_value function prints\n",
    "# the value of the global variable.\n",
    "def show_value():\n",
    "    print(my_value)\n",
    "\n",
    "# Call the show_value function.\n",
    "show_value()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# global2.py\n",
    "# Create a global variable.\n",
    "number = 0\n",
    "\n",
    "def main():\n",
    "    global number\n",
    "    number = int(input('Enter a number: '))\n",
    "    show_number()\n",
    "\n",
    "def show_number():\n",
    "    print(f'The number you entered is {number}.')\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# retirement.py\n",
    "# The following is used as a global constant to represent\n",
    "# the contribution rate.\n",
    "CONTRIBUTION_RATE = 0.05\n",
    "\n",
    "def main():\n",
    "    gross_pay = float(input('Enter the gross pay: '))\n",
    "    bonus = float(input('Enter the amount of bonuses: '))\n",
    "    show_pay_contrib(gross_pay)\n",
    "    show_bonus_contrib(bonus)\n",
    "\n",
    "# The show_pay_contrib function accepts the gross\n",
    "# pay as an argument and displays the retirement\n",
    "# contribution for that amount of pay.\n",
    "def show_pay_contrib(gross):\n",
    "    contrib = gross * CONTRIBUTION_RATE\n",
    "    print(f'Contribution for gross pay: ${contrib:,.2f}')\n",
    "\n",
    "# The show_bonus_contrib function accepts the\n",
    "# bonus amount as an argument and displays the\n",
    "# retirement contribution for that amount of pay.\n",
    "def show_bonus_contrib(bonus):\n",
    "    contrib = bonus * CONTRIBUTION_RATE\n",
    "    print(f'Contribution for bonuses: ${contrib:.2f}')\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# random_numbers.py\n",
    "# This program displays a random number\n",
    "# in the range of 1 through 10.\n",
    "import random\n",
    "\n",
    "def main():\n",
    "    # Get a random number.\n",
    "    number = random.randint(1, 10)\n",
    "    # Display the number.\n",
    "    print(f'The number is {number}.')\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# random_numbers2.py\n",
    "# This program displays five random\n",
    "# numbers in the range of 1 through 100.\n",
    "import random\n",
    "\n",
    "def main():\n",
    "    for count in range(5):\n",
    "        # Get a random number.\n",
    "        number = random.randint(1, 100)\n",
    "        # Display the number.\n",
    "        print(number)\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# random_numbers3.py\n",
    "# This program displays five random\n",
    "# numbers in the range of 1 through 100.\n",
    "import random\n",
    "\n",
    "def main():\n",
    "    for count in range(5):\n",
    "        print(random.randint(1, 100))\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dice.py\n",
    "# This program simulates the rolling of dice.\n",
    "import random\n",
    "\n",
    "# Constants for the minimum and maximum random numbers\n",
    "MIN = 1\n",
    "MAX = 6\n",
    "\n",
    "def main():\n",
    "    # Create a variable to control the loop.\n",
    "    again = 'y'\n",
    "\n",
    "    # Simulate rolling the dice.\n",
    "    while again == 'y' or again == 'Y':\n",
    "        print('Rolling the dice...')\n",
    "        print('Their values are:')\n",
    "        print(random.randint(MIN, MAX))\n",
    "        print(random.randint(MIN, MAX))\n",
    "\n",
    "        # Do another roll of the dice?\n",
    "        again = input('Roll them again? (y = yes): ')\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# coin_toss.py\n",
    "# This program simulates 10 tosses of a coin.\n",
    "import random\n",
    "\n",
    "# Constants\n",
    "HEADS = 1\n",
    "TAILS = 2\n",
    "TOSSES = 10\n",
    "\n",
    "def main():\n",
    "    for toss in range(TOSSES):\n",
    "        # Simulate the coin toss.\n",
    "        if random.randint(HEADS, TAILS) == HEADS:\n",
    "            print('Heads')\n",
    "        else:\n",
    "            print('Tails')\n",
    "            \n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# total_ages.py\n",
    "# This program uses the return value of a function.\n",
    "\n",
    "def main():\n",
    "    # Get the user's age.\n",
    "    first_age = int(input('Enter your age: '))\n",
    "\n",
    "    # Get the user's best friend's age.\n",
    "    second_age = int(input(\"Enter your best friend's age: \"))\n",
    "\n",
    "    # Get the sum of both ages.\n",
    "    total = sum(first_age, second_age)\n",
    "\n",
    "    # Display the total age.\n",
    "    print(f'Together you are {total} years old.')\n",
    "\n",
    "# The sum function accepts two numeric arguments and\n",
    "# returns the sum of those arguments.\n",
    "def sum(num1, num2):\n",
    "    result = num1 + num2\n",
    "    return result\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sale_price.py\n",
    "# This program calculates a retail item's\n",
    "# sale price.\n",
    "\n",
    "# DISCOUNT_PERCENTAGE is used as a global\n",
    "# constant for the discount percentage.\n",
    "DISCOUNT_PERCENTAGE = 0.20\n",
    "\n",
    "# The main function.\n",
    "def main():\n",
    "    # Get the item's regular price.\n",
    "    reg_price = get_regular_price()\n",
    "\n",
    "    # Calculate the sale price.\n",
    "    sale_price = reg_price - discount(reg_price)\n",
    "\n",
    "    # Display the sale price.\n",
    "    print(f'The sale price is ${sale_price:,.2f}')\n",
    "\n",
    "# The get_regular_price function prompts the\n",
    "# user to enter an item's regular price and it\n",
    "# returns that value.\n",
    "def get_regular_price():\n",
    "    price = float(input(\"Enter the item's regular price: \"))\n",
    "    return price\n",
    "\n",
    "# The discount function accepts an item's price\n",
    "# as an argument and returns the amount of the\n",
    "# discount, specified by DISCOUNT_PERCENTAGE.\n",
    "def discount(price):\n",
    "    return price * DISCOUNT_PERCENTAGE\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# commission_rate.py\n",
    "############################### INCLUDES ALL FUNCTIONS ##################################\n",
    "# This program calculates a salesperson's pay\n",
    "# at Make Your Own Music.\n",
    "def main():\n",
    "    # Get the amount of sales.\n",
    "    sales = get_sales()\n",
    "\n",
    "    # Get the amount of advanced pay.\n",
    "    advanced_pay = get_advanced_pay()\n",
    "\n",
    "    # Determine the commission rate.\n",
    "    comm_rate = determine_comm_rate(sales)\n",
    "\n",
    "    # Calculate the pay.\n",
    "    pay = sales * comm_rate - advanced_pay\n",
    "\n",
    "    # Display the amount of pay.\n",
    "    print(f'The pay is ${pay:,.2f}.')\n",
    "\n",
    "    # Determine whether the pay is negative.\n",
    "    if pay < 0:\n",
    "        print('The salesperson must reimburse')\n",
    "        print('the company.')\n",
    "\n",
    "# The get_sales function gets a salesperson's\n",
    "# monthly sales from the user and returns that value.\n",
    "def get_sales():\n",
    "    # Get the amount of monthly sales.\n",
    "    monthly_sales = float(input('Enter the monthly sales: '))\n",
    "\n",
    "    # Return the amount entered.\n",
    "    return monthly_sales\n",
    "\n",
    "# The get_advanced_pay function gets the amount of\n",
    "# advanced pay given to the salesperson and returns\n",
    "# that amount.\n",
    "def get_advanced_pay():\n",
    "    # Get the amount of advanced pay.\n",
    "    print('Enter the amount of advanced pay, or')\n",
    "    print('enter 0 if no advanced pay was given.')\n",
    "    advanced = float(input('Advanced pay: '))\n",
    "\n",
    "    # Return the amount entered.\n",
    "    return advanced\n",
    "\n",
    "# The determine_comm_rate function accepts the\n",
    "# amount of sales as an argument and returns the\n",
    "# applicable commission rate.\n",
    "def determine_comm_rate(sales):\n",
    "    # Determine the commission rate.\n",
    "    if sales < 10000.00:\n",
    "        rate = 0.10\n",
    "    elif sales >= 10000 and sales <= 14999.99:\n",
    "        rate = 0.12\n",
    "    elif sales >= 15000 and sales <= 17999.99:\n",
    "        rate = 0.14\n",
    "    elif sales >= 18000 and sales <= 21999.99:\n",
    "        rate = 0.16\n",
    "    else:\n",
    "        rate = 0.18\n",
    "\n",
    "    # Return the commission rate.\n",
    "    return rate\n",
    "\n",
    "# Call the main function\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# none_demo.py\n",
    "# This program demonstrates the None keyword.\n",
    "\n",
    "def main():\n",
    "    # Get two numbers from the user.\n",
    "    num1 = int(input('Enter a number: '))\n",
    "    num2 = int(input('Enter another number: ')) \n",
    "    \n",
    "    # Call the divide function.\n",
    "    quotient = divide(num1, num2)\n",
    "    \n",
    "    # Display the result.\n",
    "    if quotient is None:\n",
    "        print('Cannot divide by zero.')\n",
    "    else:\n",
    "        print(f'{num1} divided by {num2} is {quotient}')\n",
    "        \n",
    "# The divide function divides num1 by num2 and\n",
    "# returns the result. If num2 is 0, the function\n",
    "# returns None.\n",
    "def divide(num1, num2):\n",
    "    if num2 == 0:\n",
    "        result = None\n",
    "    else:\n",
    "        result = num1 / num2\n",
    "    return result\n",
    "\n",
    "#Execute the main function\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# square_root.py\n",
    "# This program demonstrates the sqrt function.\n",
    "import math\n",
    "\n",
    "def main():\n",
    "    # Get a number.\n",
    "    number = float(input('Enter a number: '))\n",
    "\n",
    "    # Get the square root of the number.\n",
    "    square_root = math.sqrt(number)\n",
    "\n",
    "    # Display the square root.\n",
    "    print(f'The square root of {number} is {square_root}')\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hypotenuse.py\n",
    "# This program calculates the length of a right\n",
    "# triangle's hypotenuse.\n",
    "import math\n",
    "\n",
    "def main():\n",
    "    # Get the length of the triangle's two sides.\n",
    "    a = float(input('Enter the length of side A: '))\n",
    "    b = float(input('Enter the length of side B: '))\n",
    "\n",
    "    # Calculate the length of the hypotenuse.\n",
    "    c = math.hypot(a, b)\n",
    "\n",
    "    # Display the length of the hypotenuse.\n",
    "    print(f'The length of the hypotenuse is {c}')\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MODULES: Modules are files that contain __function definitions__.\n",
    "* They don't run. You __import them__ to gain access to the functions.\n",
    "* Python has a vast library of modules that you can install and use.\n",
    "* You can __create your own__, too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NOTE: circle.py and rectangle.py are **modules** saved on this site, displayed here for your convenience."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# circle.py\n",
    "################################ DOESN'T RUN. IT'S A MODULE FILE ##########################\n",
    "# The circle module has functions that perform\n",
    "# calculations related to circles.\n",
    "import math\n",
    "\n",
    "# The area function accepts a circle's radius as an\n",
    "# argument and returns the area of the circle.\n",
    "def area(radius):\n",
    "    return math.pi * radius**2\n",
    "\n",
    "# The circumference function accepts a circle's\n",
    "# radius and returns the circle's circumference.\n",
    "def circumference(radius):\n",
    "    return 2 * math.pi * radius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rectangle.py\n",
    "################################ DOESN'T RUN. IT'S A MODULE FILE ##########################\n",
    "# The rectangle module has functions that perform\n",
    "# calculations related to rectangles.\n",
    "\n",
    "# The area function accepts a rectangle's width and\n",
    "# length as arguments and returns the rectangle's area.\n",
    "def area(width, length):\n",
    "    return width * length\n",
    "\n",
    "# The perimeter function accepts a rectangle's width\n",
    "# and length as arguments and returns the rectangle's\n",
    "# perimeter.\n",
    "def perimeter(width, length):\n",
    "    return 2 * (width + length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# geometry.py \n",
    "# This program allows the user to choose various\n",
    "# geometry calculations from a menu. This program\n",
    "# imports the circle and rectangle modules.\n",
    "import circle\n",
    "import rectangle\n",
    "\n",
    "# Constants for the menu choices\n",
    "AREA_CIRCLE_CHOICE = 1\n",
    "CIRCUMFERENCE_CHOICE = 2\n",
    "AREA_RECTANGLE_CHOICE = 3\n",
    "PERIMETER_RECTANGLE_CHOICE = 4\n",
    "QUIT_CHOICE = 5\n",
    "\n",
    "# The main function.\n",
    "def main():\n",
    "    # The choice variable controls the loop\n",
    "    # and holds the user's menu choice.\n",
    "    choice = 0\n",
    "\n",
    "    while choice != QUIT_CHOICE:\n",
    "        # display the menu.\n",
    "        display_menu()\n",
    "\n",
    "        # Get the user's choice.\n",
    "        choice = int(input('Enter your choice: '))\n",
    "\n",
    "        # Perform the selected action.\n",
    "        if choice == AREA_CIRCLE_CHOICE:\n",
    "            radius = float(input(\"Enter the circle's radius: \"))\n",
    "            print(f'The area is {circle.area(radius)}.')\n",
    "        elif choice == CIRCUMFERENCE_CHOICE:\n",
    "            radius = float(input(\"Enter the circle's radius: \"))\n",
    "            print(f'The circumference is {circle.circumference(radius)}.')\n",
    "        elif choice == AREA_RECTANGLE_CHOICE:\n",
    "            width = float(input(\"Enter the rectangle's width: \"))\n",
    "            length = float(input(\"Enter the rectangle's length: \"))\n",
    "            print(f'The area is {rectangle.area(width, length)}.')\n",
    "        elif choice == PERIMETER_RECTANGLE_CHOICE:\n",
    "            width = float(input(\"Enter the rectangle's width: \"))\n",
    "            length = float(input(\"Enter the rectangle's length: \"))\n",
    "            print(f'The perimeter is {rectangle.perimeter(width, length)}.')\n",
    "        elif choice == QUIT_CHOICE:\n",
    "            print('Exiting the program...')\n",
    "        else:\n",
    "            print('Error: invalid selection.')\n",
    "    \n",
    "# The display_menu function displays a menu.\n",
    "def display_menu():\n",
    "    print('        MENU')\n",
    "    print('1) Area of a circle')\n",
    "    print('2) Circumference of a circle')\n",
    "    print('3) Area of a rectangle')\n",
    "    print('4) Perimeter of a rectangle')\n",
    "    print('5) Quit')\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rectangle2.py\n",
    "# The area function accepts a rectangle's width and\n",
    "# length as arguments and returns the rectangle's area.\n",
    "def area(width, length):\n",
    "    return width * length\n",
    "\n",
    "# The perimeter function accepts a rectangle's width\n",
    "# and length as arguments and returns the rectangle's\n",
    "# perimeter.\n",
    "def perimeter(width, length):\n",
    "    return 2 * (width + length)\n",
    "\n",
    "# The main function is used to test the other functions.\n",
    "def main():\n",
    "    width = float(input(\"Enter the rectangle's width: \"))\n",
    "    length = float(input(\"Enter the rectangle's length: \"))\n",
    "    print('The area is', area(width, length))\n",
    "    print('The perimeter is', perimeter(width, length))\n",
    "\n",
    "# Call the main function ONLY if the file is being run as\n",
    "# a standalone program.\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The programs below crash on this server.\n",
    "* Copy-paste each into an IDLE **script window** to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# draw_squares.py\n",
    "\n",
    "import turtle\n",
    "\n",
    "def main():\n",
    "    turtle.hideturtle()\n",
    "    square(100, 0, 50, 'red')\n",
    "    square(-150, -100, 200, 'blue')\n",
    "    square(-200, 150, 75, 'green')\n",
    "\n",
    "# The square function draws a square. The x and y parameters\n",
    "# are the coordinates of the lower-left corner. The width\n",
    "# parameter is the width of each side. The color parameter\n",
    "# is the fill color, as a string.\n",
    "\n",
    "def square(x, y, width, color):\n",
    "    turtle.penup()            # Raise the pen\n",
    "    turtle.goto(x, y)         # Move to the specified location\n",
    "    turtle.fillcolor(color)   # Set the fill color\n",
    "    turtle.pendown()          # Lower the pen\n",
    "    turtle.begin_fill()       # Start filling\n",
    "    for count in range(4):    # Draw a square\n",
    "        turtle.forward(width)\n",
    "        turtle.left(90)\n",
    "    turtle.end_fill()         # End filling\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# draw_circles.py\n",
    "\n",
    "import turtle\n",
    "\n",
    "def main():\n",
    "    turtle.hideturtle()\n",
    "    circle(0, 0, 100, 'red')\n",
    "    circle(-150, -75, 50, 'blue')\n",
    "    circle(-200, 150, 75, 'green')\n",
    "\n",
    "# The circle function draws a circle. The x and y parameters\n",
    "# are the coordinates of the center point. The radius\n",
    "# parameter is the circle's radius. The color parameter\n",
    "# is the fill color, as a string.\n",
    "\n",
    "def circle(x, y, radius, color):\n",
    "    turtle.penup()             # Raise the pen\n",
    "    turtle.goto(x, y - radius) # Position the turtle\n",
    "    turtle.fillcolor(color)    # Set the fill color\n",
    "    turtle.pendown()           # Lower the pen\n",
    "    turtle.begin_fill()        # Start filling\n",
    "    turtle.circle(radius)      # Draw a circle\n",
    "    turtle.end_fill()          # End filling\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# draw_lines.py\n",
    "\n",
    "import turtle\n",
    "\n",
    "# Named constants for the triangle's points\n",
    "TOP_X = 0\n",
    "TOP_Y = 100\n",
    "BASE_LEFT_X = -100\n",
    "BASE_LEFT_Y = -100\n",
    "BASE_RIGHT_X = 100\n",
    "BASE_RIGHT_Y = -100\n",
    "\n",
    "def main():\n",
    "    turtle.hideturtle()\n",
    "    line(TOP_X, TOP_Y, BASE_LEFT_X, BASE_LEFT_Y, 'red')\n",
    "    line(TOP_X, TOP_Y, BASE_RIGHT_X, BASE_RIGHT_Y, 'blue')\n",
    "    line(BASE_LEFT_X, BASE_LEFT_Y, BASE_RIGHT_X, BASE_RIGHT_Y, 'green')\n",
    "\n",
    "# The line function draws a line from (startX, startY)\n",
    "# to (endX, endY). The color parameter is the line's color.\n",
    "\n",
    "def line(startX, startY, endX, endY, color):\n",
    "    turtle.penup()              # Raise the pen\n",
    "    turtle.goto(startX, startY) # Move to the starting point\n",
    "    turtle.pendown()            # Lower the pen\n",
    "    turtle.pencolor(color)      # Set the pen color\n",
    "    turtle.goto(endX, endY)     # Draw a square\n",
    "\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# my_graphics.py\n",
    "################################ DOESN'T RUN. IT'S A MODULE FILE ##########################\n",
    "# Turtle graphics functions\n",
    "import turtle\n",
    "\n",
    "# The square function draws a square. The x and y parameters\n",
    "# are the coordinates of the lower-left corner. The width\n",
    "# parameter is the width of each side. The color parameter\n",
    "# is the fill color, as a string.\n",
    "\n",
    "def square(x, y, width, color):\n",
    "    turtle.penup()            # Raise the pen\n",
    "    turtle.goto(x, y)         # Move to the specified location\n",
    "    turtle.fillcolor(color)   # Set the fill color\n",
    "    turtle.pendown()          # Lower the pen\n",
    "    turtle.begin_fill()       # Start filling\n",
    "    for count in range(4):    # Draw a square\n",
    "        turtle.forward(width)\n",
    "        turtle.left(90)\n",
    "    turtle.end_fill()         # End filling\n",
    "\n",
    "# The circle function draws a circle. The x and y parameters\n",
    "# are the coordinates of the center point. The radius\n",
    "# parameter is the circle's radius. The color parameter\n",
    "# is the fill color, as a string.\n",
    "\n",
    "def circle(x, y, radius, color):\n",
    "    turtle.penup()             # Raise the pen\n",
    "    turtle.goto(x, y - radius) # Position the turtle\n",
    "    turtle.fillcolor(color)    # Set the fill color\n",
    "    turtle.pendown()           # Lower the pen\n",
    "    turtle.begin_fill()        # Start filling\n",
    "    turtle.circle(radius)      # Draw a circle\n",
    "    turtle.end_fill()          # End filling\n",
    "\n",
    "# The line function draws a line from (startX, startY)\n",
    "# to (endX, endY). The color parameter is the line's color.\n",
    "\n",
    "def line(startX, startY, endX, endY, color):\n",
    "    turtle.penup()              # Raise the pen\n",
    "    turtle.goto(startX, startY) # Move to the starting point\n",
    "    turtle.pendown()            # Lower the pen\n",
    "    turtle.pencolor(color)      # Set the pen color\n",
    "    turtle.goto(endX, endY)     # Draw a square"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# graphics_mod_demo.py\n",
    "################################ THIS RUNS, IMPORTS MODULE FILE ABOVE ##########################\n",
    "import turtle\n",
    "import my_graphics\n",
    "\n",
    "# Named constants\n",
    "X1 = 0\n",
    "Y1 = 100\n",
    "X2 = -100\n",
    "Y2 = -100\n",
    "X3 = 100\n",
    "Y3 = -100\n",
    "RADIUS = 50\n",
    "\n",
    "def main():\n",
    "    turtle.hideturtle()\n",
    "\n",
    "    # Draw a square.\n",
    "    my_graphics.square(X2, Y2, (X3 - X2), 'gray')\n",
    "\n",
    "    # Draw some circles.\n",
    "    my_graphics.circle(X1, Y1, RADIUS, 'blue')\n",
    "    my_graphics.circle(X2, Y2, RADIUS, 'red')\n",
    "    my_graphics.circle(X3, Y3, RADIUS, 'green')\n",
    "\n",
    "    # Draw some lines.\n",
    "    my_graphics.line(X1, Y1, X2, Y2, 'black')\n",
    "    my_graphics.line(X1, Y1, X3, Y3, 'black')\n",
    "    my_graphics.line(X2, Y2, X3, Y3, 'black')\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now try some end-of-chapter Programming Exercises."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "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.8.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}