cs11_assign3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![logo](delta-logo.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CS 11 Assignment 3: Python Programming\n",
    "\n",
    "You will use Python to design a shape of your choosing. Be creative, the **top 3 shapes** will earn an **extra 5 points**.\n",
    "\n",
    "You will first start by getting familiar with the Python programming language by reading the instructions and completing the tasks below. To execute a cell, press **shift+enter** or use one of the options under the **Cell** menu. Some cells depend on the execution of the previous cell so make sure all previous cells have been executed.\n",
    "\n",
    "Below is an overview of the main Python features needed to successfully complete the implementation phase. For the complete Python tutorial go to [W3 School's Python Tutorial](https://www.w3schools.com/python/default.asp)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Indentation\n",
    "\n",
    "Indentation refers to the spaces at the beginning of a code line. \n",
    "\n",
    "In other programming languages the indentation in code is for readability only, the indentation in Python is very important. Python uses indentation to indicate a block of code. \n",
    "\n",
    "The number of spaces is up to the programmer but it has to be at least one.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example:\n",
    "\n",
    "Press **shift+enter** to execute each cell below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if True:\n",
    "    print(\"CS 11 Asssignment 3: Python Programming\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python will give an error if identation is missing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if True:\n",
    "print(\"CS 11 Assignement 3: Python Programming\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Comments\n",
    "\n",
    "Comments in programming can be used for various reasons. Some of the main reasons include:\n",
    "1. Explain different parts of the source code\n",
    "2. Prevent portions of the code from executing when testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a Comment\n",
    "Comments start with a # and everthing on the same line as # is ignored by Python. Comments are a message to human readers and can help make your program a lot easier to understand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a comment\n",
    "print(\"My first comment\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"My second comment\") # This is also a comment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A comment does not have to be text that explains the code, it can also be used to prevent Python from executing code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(\"My second comment\")\n",
    "print(\"I just prevented my second comment from printing\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To add multi-line comments use triple quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Here is an example of multi-line comments.\n",
    "Just surround the text with triple quotes and \n",
    "it will be ignored by Python.\n",
    "\"\"\"\n",
    "print(\"My first multi-line comment\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Variables\n",
    "Variables, in general, are containers for storing data values.\n",
    "\n",
    "In Python, a variable is created the moment you first assign a value to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 6\n",
    "total = x + y\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variable names in Python are case sensitive. So the variable named **var1** is different than the variable named **Var1**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will create two variables\n",
    "a = 5\n",
    "A = 10\n",
    "print(\"a = %d and A = %d\" % (a, A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Task 1: Create a variable and assign it a value\n",
    "\n",
    "\n",
    "# Task 2: print the variable\n",
    "\n",
    "\n",
    "# To print a variable just enter **print(name of variable)**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Strings\n",
    "\n",
    "Strings in python are surrounded by either single quotation marks or double quotation marks.\n",
    "\n",
    "'my string' is the same as \"my string\".\n",
    "\n",
    "You can display strings with the `print()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"My first string with quotation marks\")\n",
    "print('My first string with single quotes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get the length of a string by using Python's built-in `len()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"My second string with quotation marks\"\n",
    "length = len(s)\n",
    "print(\"Length of s is: {}\".format(length))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Task 3: Assign a string to a variable.\n",
    "\n",
    "\n",
    "# Task 4: Print the string\n",
    "\n",
    "\n",
    "# Task 5: Print the length of the string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Booleans\n",
    "\n",
    "Booleans represent one of two values: `True` or `False`.\n",
    "\n",
    "In programming you often need to know if an expression is True or False.\n",
    "\n",
    "You can evaluate any expression in Python, and get one of two answers, True or False.\n",
    "\n",
    "When you compare two values, the expression is evaluated and Python returns the Boolean answer:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python Greater than comparison operator\n",
    "print(1 > 7)\n",
    "\n",
    "# Python Less than comparison operator\n",
    "print(5 < 2)\n",
    "\n",
    "# Python Equal comparison operator\n",
    "print(3 == 2+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For other operators to use in addition to `>`, `<`, and `==` see: [Python Operators](https://www.w3schools.com/python/python_operators.asp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Lists\n",
    "\n",
    "Lists are used to store multiple items in a single variable.\n",
    "\n",
    "Lists are one of 4 built-in data types in Python used to store collections of data, the other 3 are Tuple, Set, and Dictionary, all with different qualities and usage.\n",
    "\n",
    "Lists are created using square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list of numbers\n",
    "numbers = [10, 3, 6, 7, 8]\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List items are indexed. So the first item starts a 0, the second item at 1, etc.\n",
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the first and second number in the list of numbers above\n",
    "\n",
    "# The first number\n",
    "print(numbers[0])\n",
    "\n",
    "# The second number\n",
    "print(numbers[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The len() function can be used to determine the number of items in the list.\n",
    "\n",
    "print(len(numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Task 6: Create a list of 10 numbers \n",
    "\n",
    "# Task 7: print the first three numbers\n",
    "\n",
    "# Task 8: print the length of the list\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Conditions and If Statements\n",
    "\n",
    "Python supports the usual logical conditions from mathematics:\n",
    "\n",
    "* Equals: `a == b`\n",
    "* Not Equals: `a != b`\n",
    "* Less than: `a < b`\n",
    "* Less than or equal to: `a <= b`\n",
    "* Greater than: `a > b`\n",
    "* Greater than or equal to: `a >= b`\n",
    "\n",
    "These conditions can be used in several ways, most commonly in **if statements** and loops.\n",
    "\n",
    "### If\n",
    "\n",
    "An **if statement** is written by using the `if` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 20\n",
    "if(x < y):\n",
    "    print(\"x is less than y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Elif\n",
    "\n",
    "The `elif` keyword is pythons way of saying \"if the previous conditions were not true, then try this condition\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if(x > y):\n",
    "    print(\"x is greater than y\")\n",
    "elif(x < y):\n",
    "    print(\"x is less than y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Else\n",
    "The `else` keyword catches anything which isn't caught by the preceding conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 10\n",
    "\n",
    "if(x < y):\n",
    "    print(\"x is less than y\")\n",
    "elif(x > y):\n",
    "    print(\"x is greater than y\")\n",
    "else:\n",
    "    print(\"x is equal to y\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = 199\n",
    "v = 200\n",
    "\n",
    "# TASK 9: Write an if...elif...else statement that prints \"Equals\" if u is equal to v,\n",
    "#         \"Less Than\" if u is less than v, and \"Greater than\" if u is greater than v.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python For Loops\n",
    "\n",
    "A `for` loop is used to iterate over a list of items.\n",
    "\n",
    "With the for loop we can execute a set of statements, once for each item in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print each number in the list\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8]\n",
    "for num in numbers:\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The range() Function\n",
    "To loop through a set of code a specified number of times, we can use the `range()` function,\n",
    "The `range()` function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and ends at a specified number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# An alternative way to print the above list of numbers is\n",
    "\n",
    "# Get the size of the list\n",
    "size = len(numbers)\n",
    "\n",
    "for i in range(size):    # defaults to: range(0, size, 1)\n",
    "    print(numbers[i])\n",
    "   \n",
    "# Print a newline\n",
    "print(\"\\n\")\n",
    "    \n",
    "# Is the same as doing\n",
    "for i in range(0, size, 1):   # range(start, end, increment)\n",
    "    print(numbers[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To skip every other number in the list\n",
    "for i in range(0, size, 2):  # i = 0, 2, 4, 6\n",
    "    print(numbers[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested Loops\n",
    "A nested loop is a loop inside a loop.\n",
    "\n",
    "The **inner loop** will be executed one time for each iteration of the **outer loop**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compare numbers at different positions in same list\n",
    "numbers = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n",
    "size = len(numbers)\n",
    "\n",
    "for i in range(size-1):  # range(0, 10, 1)\n",
    "    for j in range(i+1, size):  # range(i+1, 11, 1)\n",
    "        if numbers[i] > numbers[j]:\n",
    "            print(\"Number at position {} is greater than number at position {}\".format(i, j))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Task 10: Create a for loop that prints each number in the list below\n",
    "numbers = [2, 4, 6, 8, 10]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Functions (Methods)\n",
    "\n",
    "[Python functions](https://www.w3schools.com/python/python_functions.asp) are blocks of code that only runs when called.\n",
    "\n",
    "## Arguments\n",
    "Information can be passed into functions as arguments.\n",
    "\n",
    "Arguments are specified after the function name, inside the parentheses. The documentation for the function will tell you how many arguments you can specify after the function name. If a function takes multiple arguments you need to separate them with a comma."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Turle Graphics was invented in the 1960s by computing educator Seymour Papert. Below is a turtle module designed for Jupyter notebook. The source code repository can be accessed [here](https://github.com/takluyver/mobilechelonian) on GitHub. To get started review and run the code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Import the turtle module\n",
    "from mobilechelonian import Turtle\n",
    "\n",
    "# 2. Create a turtle and assign it to the variable fred\n",
    "fred = Turtle()\n",
    "\n",
    "# 3. Call the different Turtle functions\n",
    "\n",
    "# pencolor(color) - The function pencolor takes one argument and is called when you want to\n",
    "# change the color of the pen to color. Default is black.\n",
    "# Valid color names are listed here: https://www.w3schools.com/cssref/css_colors.asp\n",
    "fred.pencolor(\"firebrick\")\n",
    "\n",
    "# forward(num) - Move the Turtle forward by num units.\n",
    "fred.forward(100)\n",
    "\n",
    "# right(degrees) - Turn the Turtle number of degrees to the right.\n",
    "fred.right(135)\n",
    "\n",
    "fred.pencolor(\"blue\")\n",
    "fred.forward(140)\n",
    "fred.right(135)\n",
    "fred.pencolor(\"green\")\n",
    "fred.forward(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amy = Turtle()\n",
    "\n",
    "# speed(speed) - Change the speed of the turtle (range 1-10).\n",
    "amy.speed(5)\n",
    "amy.pencolor(\"green\")\n",
    "\n",
    "# instead of writing each step you can use a For loop!\n",
    "for side in [1, 2, 3, 4]:\n",
    "    amy.forward(100)\n",
    "    amy.right(90)\n",
    "\n",
    "# penup() - Lift up the pen.\n",
    "amy.penup()\n",
    "amy.right(-90)\n",
    "\n",
    "# pendown() - put down the pen. Turtles start with their pen down.\n",
    "amy.pendown()\n",
    "amy.pencolor(\"red\")\n",
    "for side in [1, 2, 3, 4]:\n",
    "    amy.forward(100)\n",
    "    amy.right(90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Final Task\n",
    "\n",
    "For your final task, use the **Turtle** module to create your own shape(s). There are two examples below of an arrow and star. Five extra credit points will be given to the three best shapes created.\n",
    "\n",
    "## Example Shapes:\n",
    "\n",
    "![Arrow](arrow.png)\n",
    "\n",
    "![Star](star.png)\n",
    "\n",
    "\n",
    "## Turtle Functions:\n",
    "\n",
    "### backward(num) - Move the Turtle backward by num units.\n",
    "    \n",
    "    Example:: t.backward(100)\n",
    " \n",
    "### circle(radius, extent=360) - Draw a circle, or part of a circle. From its current position, the turtle will draw a series of short lines, turning slightly between each. If radius is positive, it will turn to its left; a negative radius will make it turn to its right.\n",
    "\n",
    "    Example:: t.circle(50)\n",
    "\n",
    "### forward(num) - Move the Turtle forward by num units.\n",
    "    \n",
    "    Example:: t.forward(100)\n",
    "  \n",
    "### home() - Move the Turtle to its home position.\n",
    "\n",
    "    Example:: t.home()\n",
    " \n",
    "### left(num) - Turn the Turtle num degrees to the left.\n",
    "\n",
    "    Example:: t.left(90)\n",
    "  \n",
    "### pencolor(color) - Change the color of the pen to color. Default is black.\n",
    "\n",
    "    Example:: t.pencolor(\"red\")\n",
    "   \n",
    "### pendown() - Put down the pen. Turtles start with their pen down.\n",
    "\n",
    "    Example:: t.pendown()\n",
    "    \n",
    "### penup() - Lift up the pen.\n",
    "\n",
    "    Example:: t.penup()\n",
    "\n",
    "### right(num) - Turn the Turtle num degrees to the right.\n",
    "\n",
    "    Example:: t.right(90)\n",
    "    \n",
    "### setbearing(bearing) - Change the bearing (angle) of the turtle.\n",
    "\n",
    "    Example:: t.setbearing(180) \n",
    "\n",
    "### setposition(x, y, bearing=None) - Change the position of the turtle.\n",
    "\n",
    "    Example:: t.setposition(100, 100)\n",
    "\n",
    "### speed(speed) - Change the speed of the turtle (range 1-10).\n",
    "\n",
    "    Example:: t.speed(10) # Full speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Final Task: Create your own shape\n",
    "from mobilechelonian import Turtle # DO NOT Delete - you must use this version of the Turtle module\n",
    "\n"
   ]
  }
 ],
 "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}