ex22.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 22\n",
    "### In this exercise i'm rewrite all character and symbol from previous exercise. So that's mean i must understand all the code to make a good fundamental skill"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 1\n",
    "\n",
    "print(\"Hello World!\")\n",
    "print(\"Hello Again\")\n",
    "print(\"I Like Typing This.\")\n",
    "print(\"This Is Fun.\")\n",
    "print(\"Yay! Printing.\")\n",
    "print(\"I'd much rather you 'not'.\")\n",
    "print('I \"said\" not to touch this.')\n",
    "print('Johny said \"This is crazy!\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the print function is to prins the value inside the parentheses to sys.stdout.\n",
    "\n",
    "Otherwise the parentheses is to call an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2\n",
    "\n",
    "# A comment, this is so you can read your program later.\n",
    "# Anything after the # is ignored by python.\n",
    "\n",
    "print(\"I could have code like this.\") # and the comment after is ignored.\n",
    "\n",
    "# You can also use a comment to \"disable\" or comment out a piece of code:\n",
    "# print(\"This won't run.\")\n",
    "\n",
    "print(\"This will run.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The hash # symbol is indicate line after it will be a comments section. Wich is the comment are ignored by the syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I will now count my chicken:\n",
      "Hens 30.0\n",
      "Roosters 97\n",
      "Now i will count the eggs:\n",
      "6.75\n",
      "Is it true that 3 + 2 < 5 - 7?\n",
      "False\n",
      "What is 3 + 2? 5\n",
      "What is 5 - 7? -2\n",
      "Oh that's why it's false.\n",
      "Is it greater? True\n",
      "Is it greater or equal? True\n",
      "Is it less or equal? False\n"
     ]
    }
   ],
   "source": [
    "# Exercise 3\n",
    "\n",
    "print(\"I will now count my chicken:\")\n",
    "\n",
    "print(\"Hens\", 25 + 30 / 6) #The comma after \"Hens\" is used to separate string and numerical processing\n",
    "print(\"Roosters\", 100 - 25 * 3 % 4)\n",
    "\n",
    "print(\"Now i will count the eggs:\")\n",
    "\n",
    "print(3 + 2 + 1 - 5 + 4 % 2 - 1 / 4 + 6)\n",
    "\n",
    "print(\"Is it true that 3 + 2 < 5 - 7?\")\n",
    "\n",
    "print(3 + 2 < 5 - 7) #Will gave a False answer because 5 is greater than -2\n",
    "\n",
    "print(\"What is 3 + 2?\", 3 + 2)\n",
    "print(\"What is 5 - 7?\", 5 - 7)\n",
    "\n",
    "print(\"Oh that's why it's false.\")\n",
    "\n",
    "print(\"Is it greater?\", 5 > -2)\n",
    "print(\"Is it greater or equal?\", 5 >= -2)\n",
    "print(\"Is it less or equal?\", 5 <= -2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So at Exercise 3 I've learn about operator in python. These operator help us on doing math logic in python language.\n",
    "\n",
    "Below is the student drill."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The volume of a cube with side lenght 7 is 343 cm^3\n",
      "The volume of a ball with radius 11 is 5572.453333333333 cm^3\n",
      "The volume of a pyramid with base 7 and height 12 is 196.0 cm^3\n"
     ]
    }
   ],
   "source": [
    "#Formula to know cubes volume\n",
    "print(\"The volume of a cube with side lenght 7 is\", 7 ** 3,\"cm^3\")\n",
    "\n",
    "#Formula to know a Ball volume\n",
    "print(\"The volume of a ball with radius 11 is\", (4 / 3) * 3.14 * 11 ** 3, \"cm^3\")\n",
    "\n",
    "#Formula to know a pyramid volume\n",
    "print(\"The volume of a pyramid with base 7 and height 12 is\", (7 ** 2 * 12) / 3, \"cm^3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 100 cars available.\n",
      "There are only 30 drivers available.\n",
      "There will be 70 empty cars today.\n",
      "We can transport 120.0 people today.\n",
      "We have 90 to carpool today.\n",
      "We need to put about 3.0 in each car.\n"
     ]
    }
   ],
   "source": [
    "#Exer ise 4\n",
    "\n",
    "cars = 100 #Create variable car with 100 value in float data type\n",
    "space_in_a_car = 4.0 #Create space in car variable so we knew the capacity for that car\n",
    "drivers = 30 #Create variable drivers with value 30\n",
    "passangers = 90 #Create variable passangers with value 90\n",
    "cars_not_driven = cars - drivers #Create variable cars_not_driven with value of car - drivers\n",
    "cars_driven = drivers #Indicate that cars driven is driven by a total of driver\n",
    "carpool_capcity = cars_driven * space_in_a_car #Create variable carpool_capacity with value of cars_driven * space_in_a_car\n",
    "average_passangers_per_car = passangers / cars_driven #Show average_passangers_per_car with value of passangers / cars_driven\n",
    "\n",
    "print(\"There are\", cars, \"cars available.\")\n",
    "print(\"There are only\", drivers, \"drivers available.\")\n",
    "print(\"There will be\", cars_not_driven, \"empty cars today.\")\n",
    "print(\"We can transport\", carpool_capcity, \"people today.\")\n",
    "print(\"We have\", passangers, \"to carpool today.\")\n",
    "print(\"We need to put about\", average_passangers_per_car, \"in each car.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Let's talk about Zed A. Shew.\n",
      "He's 74 inches tall.\n",
      "He's got 180 pound heavy.\n",
      "Actually that's not too heave.\n",
      "He's got Blue eyes and Brown hair.\n",
      "His teeth are usually White depending on the coffee.\n",
      "He's 187.96 cm tall.\n",
      "He's 81.64656 kg heavy.\n"
     ]
    }
   ],
   "source": [
    "#Exercise 5\n",
    "\n",
    "name = 'Zed A. Shew'\n",
    "age = 35 # not a lie\n",
    "height = 74 # inches\n",
    "weight = 180 # lbs\n",
    "eyes = 'Blue'\n",
    "teeth = 'White'\n",
    "hair = 'Brown'\n",
    "\n",
    "print(f\"Let's talk about {name}.\")\n",
    "print(f\"He's {height} inches tall.\")\n",
    "print(f\"He's got {weight} pound heavy.\")\n",
    "print(\"Actually that's not too heave.\")\n",
    "print(f\"He's got {eyes} eyes and {hair} hair.\")\n",
    "print(f\"His teeth are usually {teeth} depending on the coffee.\")\n",
    "\n",
    "#Below code is student drill\n",
    "\n",
    "heigh_cm = height * 2.54\n",
    "weight_kg = weight * 0.453592\n",
    "\n",
    "print(f\"He's {heigh_cm} cm tall.\")\n",
    "print(f\"He's {weight_kg} kg heavy.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 10 types of people.\n",
      "Those who know binary and those who don't.\n",
      "I said: There are 10 types of people.\n",
      "I also said: 'Those who know binary and those who don't.'\n",
      "Isn't that joke so funny?! True\n",
      "This is the left side of...a string with a right side.\n"
     ]
    }
   ],
   "source": [
    "types_of_people = 10 #Assigne a value of 10 to variable types_of_people\n",
    "x = f\"There are {types_of_people} types of people.\" #Assign a string to variable x\n",
    "\n",
    "binary = \"binary\" #Assign a string to variable binary\n",
    "do_not = \"don't\" #Assign a string to variable do_not\n",
    "y = f\"Those who know {binary} and those who {do_not}.\" #Assign a string to variable y\n",
    "\n",
    "print(x) #Print variable x\n",
    "print(y) #Print variable y\n",
    "\n",
    "print(f\"I said: {x}\") #Print string with variable x\n",
    "print(f\"I also said: '{y}'\") #Print string with variable y\n",
    "\n",
    "hilarious = True #Assign a boolean value to variable hilarious\n",
    "joke_evaluation = \"Isn't that joke so funny?! {}\" #Assign a string to variable joke_evaluation with variable hilarious inside it\n",
    "\n",
    "print(joke_evaluation.format(hilarious)) #Print string with variable hilarious\n",
    "\n",
    "w = \"This is the left side of...\" #Assign a string to variable w\n",
    "e = \"a string with a right side.\" #Assign a string to variable e\n",
    "\n",
    "print(w + e) #Print string with variables w and e\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mary had a little lamb.\n",
      "Its fleece was white as snow.\n",
      "And everywhere that Mary went.\n",
      "..........\n",
      "Cheese Burger\n"
     ]
    }
   ],
   "source": [
    "#Exercise 7\n",
    "\n",
    "print(\"Mary had a little lamb.\")\n",
    "print(\"Its fleece was white as {}.\".format('snow'))\n",
    "print(\"And everywhere that Mary went.\")\n",
    "print(\".\" * 10) # what'd that do?\n",
    "\n",
    "end1 = \"C\"\n",
    "end2 = \"h\"\n",
    "end3 = \"e\"\n",
    "end4 = \"e\"\n",
    "end5 = \"s\"\n",
    "end6 = \"e\"\n",
    "end7 = \"B\"\n",
    "end8 = \"u\"\n",
    "end9 = \"r\"\n",
    "end10 = \"g\"\n",
    "end11 = \"e\"\n",
    "end12 = \"r\"\n",
    "\n",
    "# watch that comma at the end. try removing it to see what happens\n",
    "print(end1 + end2 + end3 + end4 + end5 + end6, end=' ') #Combining from end1 - end6 and printng\n",
    "print(end7 + end8 + end9 + end10 + end11 + end12) #combining from end7 - end12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4\n",
      "one two three four\n",
      "True False False True\n",
      "Try your Own text here Maybe a poem Or a song about fear\n"
     ]
    }
   ],
   "source": [
    "#Exercise 8\n",
    "\n",
    "formatter = \"{} {} {} {}\" #Create function formatter with {} inside.\n",
    "\n",
    "print(formatter.format(1, 2, 3, 4))\n",
    "print(formatter.format(\"one\", \"two\", \"three\", \"four\"))\n",
    "print(formatter.format(True, False, False, True))\n",
    "print(formatter.format(\n",
    "    \"Try your\",\n",
    "    \"Own text here\",\n",
    "    \"Maybe a poem\",\n",
    "    \"Or a song about fear\"\n",
    "))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here are the days:  Mon Tue Wed Thu Fri Sat Sun\n",
      "Here are the months:  \n",
      "Jan\n",
      "Feb\n",
      "Mar\n",
      "Apr\n",
      "May\n",
      "Jun\n",
      "Jul\n",
      "Aug\n",
      "\n",
      "There's something going on here.\n",
      "With the three double-quote.\n",
      "We'll be able to type as much as we like.\n",
      "Even 4 lines if we want, or 5, or 6.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Exercise 9\n",
    "\n",
    "days = \"Mon Tue Wed Thu Fri Sat Sun\" #Assign string + variable\n",
    "months = \"\\nJan\\nFeb\\nMar\\nApr\\nMay\\nJun\\nJul\\nAug\" #Assign a string to variable months\n",
    "\n",
    "print(\"Here are the days: \", days) #Printing string + days variable\n",
    "print(\"Here are the months: \", months) #Printing string + months variable\n",
    "\n",
    "print(\"\"\"\n",
    "There's something going on here.\n",
    "With the three double-quote.\n",
    "We'll be able to type as much as we like.\n",
    "Even 4 lines if we want, or 5, or 6.\n",
    "\"\"\") #Printing with triple double-quotes\n",
    "\n",
    "#So the triple double-quotes read the enter spacing. It's really important for someone who really lazy\n",
    "#To write the code with bunch of \\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tI'm tabbed in.\n",
      "I'm split\n",
      "on a line.\n",
      "I'm \\ a \\ cat.\n",
      "\n",
      "I'll do a list:\n",
      "\t* Cat food\n",
      "\t* Fishies\n",
      "\t* Catnip\n",
      "\t* Grass\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Exercise 10\n",
    "\n",
    "tabby_cat = \"\\tI'm tabbed in.\"\n",
    "persian_cat = \"I'm split\\non a line.\"\n",
    "backslash_cat = \"I'm \\\\ a \\\\ cat.\"\n",
    "\n",
    "fat_cat = \"\"\"\n",
    "I'll do a list:\n",
    "\\t* Cat food\n",
    "\\t* Fishies\n",
    "\\t* Catnip\\n\\t* Grass\n",
    "\"\"\"\n",
    "\n",
    "print(tabby_cat)\n",
    "print(persian_cat)\n",
    "print(backslash_cat)\n",
    "print(fat_cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How old are you?\n",
      "How tall are you?\n",
      "How much do you weight?\n",
      "So, you're 24 old, 165 tall, and 99 heavy.\n"
     ]
    }
   ],
   "source": [
    "#Exercise 11\n",
    "\n",
    "print(\"How old are you?\", end='')\n",
    "age = input()\n",
    "print(\"\\nHow tall are you?\", end='')\n",
    "height = input()\n",
    "print(\"\\nHow much do you weight?\", end='')\n",
    "weight = input()\n",
    "\n",
    "print(f\"\\nSo, you're {age} old, {height} tall, and {weight} heavy.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "What do you like?\n",
      "Where do you live?\n",
      "What kind of computer do you have?\n",
      "Alright, so you said basketball about liking me.\n",
      "You live in Depok city. Not sure where that is.\n",
      "And you have a MacBook Pro computer. Nice.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Exercise 11 drill\n",
    "\n",
    "print(\"What do you like?\", end='')\n",
    "likes = input()\n",
    "print(\"\\nWhere do you live?\", end='')\n",
    "lives = input()\n",
    "print(\"\\nWhat kind of computer do you have?\", end='')\n",
    "computer = input()\n",
    "\n",
    "print(f\"\"\"\n",
    "Alright, so you said {likes} about liking me.\n",
    "You live in {lives}. Not sure where that is.\n",
    "And you have a {computer} computer. Nice.\n",
    "\"\"\") #Assign a string to variable\n",
    "\n",
    "#End in here!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "So, you're 24 old, 165 cm tall, and 98kg heavy.\n"
     ]
    }
   ],
   "source": [
    "#Exercise 12\n",
    "\n",
    "age = input(\"How old are you? \")\n",
    "height = input(\"How tall are you? \")\n",
    "weight = input(\"How much do you weight? \")\n",
    "\n",
    "print(f\"So, you're {age} old, {height} tall, and {weight} heavy.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Exercise 13\n",
    "\n",
    "from sys import argv\n",
    "\n",
    "#read the WYSS section for how to run thus\n",
    "script, first, second, third = argv\n",
    "\n",
    "print(\"The script is called:\", script)\n",
    "print(\"Your first variable is:\", first)\n",
    "print(\"Your second variable is:\", second)\n",
    "print(\"Your third variable is:\", third)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Exercise 13 Drill\n",
    "\n",
    "from sys import argv\n",
    "# read the WYSS section for how to run this\n",
    "\n",
    "script, name, degree, skill = argv\n",
    "\n",
    "print(\"The script is called:\", script)\n",
    "print(\"Your name is:\", name)\n",
    "print(\"Your have a \", degree, \"degree.\")\n",
    "print(\"Your have a\", skill, \"skill.\")\n",
    "\n",
    "input(\"Press Enter to continue...\")\n",
    "likes = input(\"What do you like? \")\n",
    "print(\"So you had a\", likes, \"in your life and the you get your\", degree, \"degree.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Exercise 14\n",
    "\n",
    "from sys import argv\n",
    "\n",
    "script, user_name = argv\n",
    "prompt = '> '\n",
    "\n",
    "print(f\"Hi {user_name}, I'm the {script} script.\")\n",
    "print(\"I'd like to ask you a few question.\")\n",
    "print(f\"Do you like me {user_name}?\")\n",
    "likes = input(prompt)\n",
    "\n",
    "print(f\"Where do you live {user_name}?\")\n",
    "lives = input(prompt)\n",
    "\n",
    "print(\"What kind of computer do you have?\")\n",
    "computer = input(prompt)\n",
    "\n",
    "print(f\"\"\"\n",
    "Alright, so you said {likes} about liking me.\n",
    "You live in {lives}. Not sure where that is.\n",
    "And you have a {computer} computer. Nice.\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Exercise 15\n",
    "\n",
    "from sys import argv #import argv from sys\n",
    "\n",
    "script, filename = argv #unpack argv from script and filename\n",
    "\n",
    "txt = open(filename) #Open the file\n",
    "\n",
    "print(f\"Here's your file {filename}:\") #print a string with formated argv filename\n",
    "print(txt.read()) #read the file\n",
    "txt.close() #close the file.\n",
    "\n",
    "print(\"Type the file name again:\") #print a string to ask user input for file name\n",
    "file_again = input(\"> \") #ask user for filename\n",
    "\n",
    "txt_again = open(file_again) #open the file again\n",
    "\n",
    "print(txt_again.read()) #read the file again from variable txt_again\n",
    "\n",
    "txt_again.close() #close the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sys import argv\n",
    "\n",
    "script, filename = argv\n",
    "\n",
    "print(f\"We're going to erase {filename}.\")\n",
    "print(\"If you don't want that, hit CTRL-C (^C)\")\n",
    "print(\"If you do want that, hit RETURN.\")\n",
    "\n",
    "input(\"?\")\n",
    "\n",
    "print(\"Opening the file...\")\n",
    "target = open(filename, 'w')\n",
    "\n",
    "print(\"Truncating the file. Goodbye!\")\n",
    "target.truncate()\n",
    "\n",
    "print(\"Now I'm going to ask you for three lines.\")\n",
    "\n",
    "line1 = input(\"line 1: \")\n",
    "line2 = input(\"line 2: \")\n",
    "line3 = input(\"line 3: \")\n",
    "\n",
    "print(\"I'm going to write these to the file.\")\n",
    "\n",
    "target.write(f\"{line1}\\n{line2}\\n{line3}\")\n",
    "\n",
    "print(\"And finaly we close it.\")\n",
    "target.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Exercise 17\n",
    "\n",
    "from sys import argv\n",
    "from os.path import exists\n",
    "\n",
    "script, from_file, to_file = argv\n",
    "\n",
    "print(f\"Copying from {from_file} to {to_file}\")\n",
    "\n",
    "#we could do these two on one line, how?\n",
    "in_file = open(from_file)\n",
    "indata = in_file.read()\n",
    "\n",
    "print(f\"The input file is {len(indata)} bytes long\")\n",
    "\n",
    "print(f\"Does the output file exist? {exists(to_file)}\")\n",
    "print(\"Ready, hit RETURN to continue, CTRL-C to abort\")\n",
    "input()\n",
    "\n",
    "out_file = open(to_file, 'w')\n",
    "out_file.write(indata)\n",
    "\n",
    "print(\"Alright, all done.\")\n",
    "\n",
    "out_file.close() #close the file\n",
    "in_file.close() #close the file\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg1: Zed, arg2: Shaw\n",
      "arg1: Zed, arg2: Shaw\n",
      "arg1: First!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.print_none()>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#this one is like your scripts with argv\n",
    "def print_two(*args):\n",
    "    arg1, arg2 = args\n",
    "    print(f\"arg1: {arg1}, arg2: {arg2}\")\n",
    "\n",
    "# ok that *args is actually pointless, we can just do this\n",
    "def print_two_again(arg1, arg2):\n",
    "    print(f\"arg1: {arg1}, arg2: {arg2}\")\n",
    "\n",
    "# this just takes one argument\n",
    "def print_one(arg1):\n",
    "    print(f\"arg1: {arg1}\")\n",
    "\n",
    "# this one takes no arguments\n",
    "def print_none():\n",
    "    print(\"I got nothin'.\")\n",
    "\n",
    "print_two(\"Zed\", \"Shaw\")\n",
    "print_two_again(\"Zed\", \"Shaw\")\n",
    "print_one(\"First!\")\n",
    "print_none"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm gonna fold it up, down, close it over the left side.\n",
      "I'm not changing anything. I just fold the papers from A4 to A6.\n",
      "Now I'm done.\n"
     ]
    }
   ],
   "source": [
    "#Exercise 18 Drill\n",
    "\n",
    "def fold(*args):\n",
    "    arg1, arg2, arg3 = args\n",
    "    print(f\"I'm gonna fold it {arg1}, {arg2}, {arg3}\")\n",
    "\n",
    "fold(\"up\", \"down\", \"close it over the left side.\")\n",
    "\n",
    "def no_changes(manpap, mandone):\n",
    "    print(f\"I'm not changing anything. I just fold the papers from {manpap} to {mandone}.\\nNow I'm done.\")\n",
    "    \n",
    "no_changes(\"A4\", \"A6\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We can just give the function numbers directly:\n",
      "You have 20 cheeses!\n",
      "You habe 30 boxes of crackers!\n",
      "Man that's enough for a party!\n",
      "Get a blanket\n",
      "\n",
      "We can use variables from our script:\n",
      "You have 10 cheeses!\n",
      "You habe 50 boxes of crackers!\n",
      "Man that's enough for a party!\n",
      "Get a blanket\n",
      "\n",
      "We can even do math inside too:\n",
      "You have 39 cheeses!\n",
      "You habe 11 boxes of crackers!\n",
      "Man that's enough for a party!\n",
      "Get a blanket\n",
      "\n",
      "And we can combine the two, variables and math:\n",
      "You have 110 cheeses!\n",
      "You habe 1050 boxes of crackers!\n",
      "Man that's enough for a party!\n",
      "Get a blanket\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Exercise 19\n",
    "\n",
    "def cheese_and_crackers(cheese_count, boxes_of_crackers):#Define a function name cheese_and_crackers\n",
    "    print(f\"You have {cheese_count} cheeses!\") #Print a formatted string with variable cheese_count\n",
    "    print(f\"You habe {boxes_of_crackers} boxes of crackers!\") #Print a formatted string with variable boxes_of_crackers\n",
    "    print(\"Man that's enough for a party!\") #Print a line of string\n",
    "    print(\"Get a blanket\\n\") #Same thing with a new line\n",
    "\n",
    "print(\"We can just give the function numbers directly:\") #Print a line of string\n",
    "cheese_and_crackers(20, 30) #Call the function\n",
    "\n",
    "print(\"We can use variables from our script:\") #Print a string\n",
    "amount_of_cheese = 10 #Assign a value of 10 to variable amount_of_cheese\n",
    "amount_of_crackers = 50 #Assign a value of 50 to variable amount_of_crack\n",
    "\n",
    "cheese_and_crackers(amount_of_cheese, amount_of_crackers) #Call the funciton\n",
    "\n",
    "print(\"We can even do math inside too:\") #Print a string\n",
    "cheese_and_crackers(19 + 20, 5 + 6) #Call the function\n",
    "\n",
    "print(\"And we can combine the two, variables and math:\") #Print a stirng\n",
    "cheese_and_crackers(amount_of_cheese + 100, amount_of_crackers + 1000) #Call the function\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Exercise 20\n",
    "\n",
    "from sys import argv\n",
    "\n",
    "script, input_file = argv\n",
    "\n",
    "def print_all(f):\n",
    "    print(f.read())\n",
    "\n",
    "def rewind(f):\n",
    "    f.seek(0)\n",
    "\n",
    "def print_a_line(line_count, f):\n",
    "    print(line_count, f.readline())\n",
    "\n",
    "current_file = open(input_file)\n",
    "\n",
    "print(\"First let's print the whole file:\\n\")\n",
    "\n",
    "print_all(current_file)\n",
    "\n",
    "print(\"\\nNow let's rewind, kind of like a tape.\")\n",
    "\n",
    "rewind(current_file)\n",
    "\n",
    "print(\"Let's print three lines:\")\n",
    "\n",
    "current_line = 1\n",
    "print_a_line(current_line, current_file)\n",
    "\n",
    "current_line = current_line + 1\n",
    "print_a_line(current_line, current_file)\n",
    "\n",
    "current_line = current_line + 1\n",
    "print_a_line(current_line, current_file)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Let's do some math with just functions:\n",
      "ADDING 30 + 5\n",
      "SUBSTRACTING 78 - 30\n",
      "MULTIPLYING 90 * 3\n",
      "DIVIDING 290 / 2\n",
      "Age: 35, Height: 48, Weight: 270, IQ: 145.0\n",
      "Here is a puzzle.\n",
      "DIVIDING 145.0 / 2\n",
      "MULTIPLYING 270 * 72.5\n",
      "SUBSTRACTING 48 - 19575.0\n",
      "ADDING 35 + -19527.0\n",
      "That becomes:  -19492.0 Can you do it by hand?\n"
     ]
    }
   ],
   "source": [
    "#Exercise 21\n",
    "\n",
    "def add(a, b): #Define a function name add\n",
    "    print(f\"ADDING {a} + {b}\") #Print a formatted string\n",
    "    return(a + b)\n",
    "\n",
    "def substract(a, b): #Define a function name subtract\n",
    "    print(f\"SUBSTRACTING {a} - {b}\") #Print a formatted string\n",
    "    return(a - b)\n",
    "\n",
    "def multiply(a, b): #Define a function name multiply\n",
    "    print(f\"MULTIPLYING {a} * {b}\") #Print a formatted string\n",
    "    return(a * b)\n",
    "\n",
    "def divide(a, b): #Define a function name divide\n",
    "    print(f\"DIVIDING {a} / {b}\") #Print a formatted string\n",
    "    return(a / b) #Return a / b\n",
    "\n",
    "print(\"Let's do some math with just functions:\")\n",
    "\n",
    "age = add(30, 5)\n",
    "height = substract(78, 30)\n",
    "weight = multiply(90, 3)\n",
    "iq = divide(290, 2)\n",
    "\n",
    "print(f\"Age: {age}, Height: {height}, Weight: {weight}, IQ: {iq}\") #Print a formatted string\n",
    "\n",
    "# A puzzle for the extra credit, type it anyway.\n",
    "print(\"Here is a puzzle.\")\n",
    "\n",
    "what = add(age, substract(height, multiply(weight, divide(iq,2))))\n",
    "\n",
    "print(\"That becomes: \", what, \"Can you do it by hand?\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}