HW_Unit_01.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/UC-Berkeley-I-School/connorwatson/blob/main/HW_Unit_01.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sbcK4aM2wvVp"
      },
      "source": [
        "## Unit 1 Assignment - DATASCI200 Introduction to Data Science Programming, UC Berkeley MIDS"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8dNqjV1-wvVq"
      },
      "source": [
        "Write code in this Jupyter Notebook to solve the following problems. Please upload this **Notebook** with your solutions to your GitHub repository and gradescope.\n",
        "\n",
        "Assignment due date: 11:59PM PT the night before the Week 2 Live Session."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cwI8XN59wvVq"
      },
      "source": [
        "## Objectives:\n",
        "\n",
        "- Demonstrate general features of a Python Notebook\n",
        "- Orient students to their choice of development environment"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "akSCxYFMwvVq"
      },
      "source": [
        "## General Guidelines:\n",
        "\n",
        "- In each code block, do NOT delete the ### comment at the top of a cell (it's needed for the auto-grading!)\n",
        "  - Full autograder tests and results are on GradeScope.\n",
        "  - You will get the full 100 points from the autograder for this assignment.\n",
        "  - You may upload and run the autograder as many times as needed in your time window to get full points\n",
        "  - The assignment needs to be named HW_Unit_01.ipynb to be graded from the autograder!\n",
        "  - The examples given are samples of how we will test/grade your code.\n",
        "    - Please ensure your code outputs the exact same information / format!\n",
        "    - In addition to the given example, the autograder will test other examples\n",
        "    - Each autograder test tells you what input it is using\n",
        "  - Once complete, the autograder will show each tests, if that test is passed or failed, and your total score\n",
        "  - The autograder fails for a couple of reasons:\n",
        "    - Your code crashes with that input (for example: `Test Failed: string index out of range`)\n",
        "    - Your code output does not match the 'correct' output (for example: `Test Failed: '1 2 3 2 1' != '1 4 6 4 1'`)\n",
        "- If you are stuck on a problem or do not understand a question - please come to office hours or ask questions to the class Google group (please don't post your code though). If it is a coding problem send a private email to all of the instructors at: mids-python-instructors@googlegroups.com.\n",
        "- We also have a TA tutors for extra help and 1 on 1 sessions!\n",
        "- Hints are given in some of the questions; these are optional so you do NOT need to use the hint (or code your answer that way) as long as your code meets the requirements of the problem.\n",
        "- You may use any libraries from the Python Standard Library for this assignment: https://docs.python.org/3/library/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TEbjgBLhwvVq"
      },
      "source": [
        "## Grading Rubric\n",
        "\n",
        "General grading rubric guidelines / philosophy:\n",
        "\n",
        "- The total possible points will be shown for each question\n",
        "- Please read each question carefully to understand the requirements\n",
        "- Points for each question are rewarded based on how well your code fulfills those requirements\n",
        "- Some problems have an example given to help show what is needed and how to format the answer\n",
        "- In those cases, specified inputs and outputs should match the examples exactly\n",
        "- For the rest of the questions, its up to you to determine the requirements and code them!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_CgcQB0mwvVr"
      },
      "source": [
        "### 1-1. The command shell. (20 points)\n",
        "\n",
        "One of the most ubiquitous ways of interacting with a computer is to use the command line, or terminal. Though we'll be using Jupyter Notebook for this class, you'll still need to issue terminal commands from time to time. Luckily, the Jupyter runtime allows us to do this directly from the notebook with a [magic command](https://ipython.readthedocs.io/en/stable/interactive/magics.html).\n",
        "\n",
        "The magic command syntax to invoke a command line command is the exclamation mark, followed by the command. The command `!pwd` will tell Jupyter to run the command `pwd` and display the results (standard output) of the command under the cell.  \n",
        "\n",
        "#### Question 1-1:\n",
        "Use the `!` magic command to do the following three operations:\n",
        "* Print the working directory\n",
        "* Write \"I love the command line!\" to a file named `HW1-1.txt` (case sensitive) in the current working directory\n",
        "* Read out the contents of `HW1-1.txt` (hint: meow!)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ptgq6-JNwvVr",
        "outputId": "57db453f-2300-4710-fdef-8946a6a1d294"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content\n",
            "I love the command line!\n",
            "HW1-1.txt  sample_data\n"
          ]
        }
      ],
      "source": [
        "### Q1-1 Grading Tag: Please put your entire solution in this cell. Don't edit this line.\n",
        "! pwd\n",
        "! touch HW1-1.txt\n",
        "! echo \"I love the command line!\" > HW1-1.txt\n",
        "! cat HW1-1.txt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g0LvPI5-wvVr"
      },
      "source": [
        "### 1-2. I git it now! (20 points)\n",
        "\n",
        "Throughout this class you'll be expected to use your git repository to save your work. We **highly** recommend getting into the habit of saving your work incrementally rather than all at once when an assignment is completed. To practice this workflow, let's go ahead and save the work we completed for Question 1-1 in git.\n",
        "\n",
        "#### Problem 1-2:\n",
        "1. Make sure this notebook file is in your git repo folder, if it's not, move it.\n",
        "2. Open a command line / terminal and issue the following commands:\n",
        "3. `git status`  \n",
        "    * Tells you what files have been changed and in what way. You should see this notebook and perhaps the `HW1-1.txt` file from the previous problem.\n",
        "4. `git add HW_Unit_01.ipynb`\n",
        "    * Makes git track the file(s) in the command, and adds them to commit staging\n",
        "5. `git commit -m \"HW1-1\"`\n",
        "    * Git takes a \"snapshot\" (commit) of the changes in the file when you staged it and uses the message you provided as a description. It's best practice to do this frequently!\n",
        "6. `git push`\n",
        "    * Sends your current changes (on the branch) to your remote repository, which is hosted on GitHub.com. If you get an error that no remote branch exists, you might have to use the following syntax: `git push -u origin main`.\n",
        "7. View your repository on GitHub.com. If the steps were followed correctly, you should see this notebook with Q1 complete.\n",
        "8. Once complete, run the command below without modifying it. An explanation of the shell command can be found here: [explainshell.com](https://www.explainshell.com/explain?cmd=git+log+--pretty%3Doneline+%7C+head+%3E+HW1-2.txt)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4mpcTsZJwvVr",
        "outputId": "15f3ca47-8d21-4f1c-92b5-dec965d3cd50"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "fatal: not a git repository (or any of the parent directories): .git\n"
          ]
        }
      ],
      "source": [
        "### Q1-2 Grading Tag: Please put your entire solution in this cell. Don't edit this line.\n",
        "\n",
        "# This cell is pre-completed. Do not modify. Run as is once steps are followed.\n",
        "!git log --pretty=oneline | head > HW1-2.txt\n",
        "!cat HW1-2.txt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QBB3sdo4wvVr"
      },
      "source": [
        "### 1-3. Hello World! (40 points)\n",
        "\n",
        "Welcome to the wonderful world of Python! Why don't we say hello?\n",
        "\n",
        "Python allows you to send output to the console (called \"standard output\") by using the `print` function. To invoke, or \"call\" the function, simply write its name, then follow it with a set of parentheses, including arguments within if necessary. For example, invoking `print('my name is bob')` will show `my name is bob` to the user of your program.\n",
        "\n",
        "Note: The quotes (single or double is acceptable) around `my name is bob` is required. You will learn why next week.\n",
        "\n",
        "#### Problem 1-3:\n",
        "Use the code cell to print `Hello World!` exactly like so. You may add more lines to the cell; make sure not to modify the grading tag on line 1.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "OHlVvCQqwvVr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "097ec6c8-bf66-4e42-c6b5-52aa15bd3e1b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello World!\n"
          ]
        }
      ],
      "source": [
        "### Q1-3 Grading Tag: Please put your entire solution in this cell. Don't edit this line.\n",
        "print(\"Hello World!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sEjb0CEqwvVr"
      },
      "source": [
        "### 1-4. A preview of things to come (20 points)\n",
        "\n",
        "In the first half of this class, we'll be focusing on Python as a programming language. We'll be covering everything from basic expressions and variable assignments, to layering and abstracting functionality in Classes. The following is a primitive example of how a student might be coded in a hypothetical gradebook.  \n",
        "\n",
        "#### Problem 1-4:\n",
        "1. Skim through the code and try to reverse engineer what's happening along the way.\n",
        "2. Modify the code as instructed in the in-line comments after the do not edit block."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "a1maX81NwvVs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3751c1e9-7cd2-48fd-acc2-79603ca13bb9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "95.3125 A\n"
          ]
        }
      ],
      "source": [
        "### Q1-4 Grading Tag: Please put your entire solution in this cell. Don't edit this line.\n",
        "\n",
        "############ BEGIN: DO NOT EDIT ############\n",
        "\n",
        "class Student:\n",
        "\n",
        "    def __init__(self, full_name, preferred_name = None):\n",
        "        \"\"\" Initializer / Constructor function. Is called whenever the Student object is created. \"\"\"\n",
        "        # Create instance attributes\n",
        "        self.first_name = None\n",
        "        self.middle_name = None\n",
        "        self.last_name = None\n",
        "        self.grades = {}\n",
        "        self.attendance = set()\n",
        "\n",
        "        # Initialize student name info\n",
        "        self.first_name, *self.middle_name, self.last_name = full_name\n",
        "        self.preferred_name = preferred_name\n",
        "\n",
        "    def add_attendance(self, date):\n",
        "        \"\"\" Adds supplied date to attendance \"\"\"\n",
        "        self.attendance.add(date)\n",
        "\n",
        "    def assign_grade(self, assignment, grade):\n",
        "        \"\"\" Assigns grades to grades dictionary on assignment name key \"\"\"\n",
        "        if grade < 0:\n",
        "            raise ValueError(f'Grade cannot be less than 0. {grade=}')\n",
        "        elif grade > 100:\n",
        "            raise ValueError(f'Grade cannot be greater than 100. {grade=}')\n",
        "\n",
        "        self.grades[assignment] = grade\n",
        "\n",
        "    def current_grade_percent(self):\n",
        "        \"\"\" Grade is a simple unweighted average \"\"\"\n",
        "        return sum(self.grades.values()) / len(self.grades)\n",
        "\n",
        "    def current_grade_letter(self, grade = None):\n",
        "        \"\"\" Maps percent grades to letter grades \"\"\"\n",
        "        major_letter_grades = ['A', 'B', 'C', 'D']\n",
        "        minor_letter_grades = ['+', '', '-']\n",
        "        grade_steps = [3, 4, 3]\n",
        "        failed = 'F'\n",
        "        max_grade = 100\n",
        "        failing_grade_noninclusive = 60\n",
        "\n",
        "        # Return either Perfect or Failing grades\n",
        "        cur_grade = self.current_grade_percent() if grade is None else grade\n",
        "        if cur_grade < failing_grade_noninclusive:\n",
        "            return failed\n",
        "        elif cur_grade >= max_grade:\n",
        "            return major_letter_grades[0] + minor_letter_grades[0]\n",
        "\n",
        "        # Compute letter grades by walking down the grade distribution\n",
        "        minor = -1\n",
        "        major = 0\n",
        "        while max_grade > cur_grade:\n",
        "            max_grade -= grade_steps[minor]\n",
        "            minor += 1\n",
        "            if minor >= len(grade_steps):\n",
        "                minor = 0\n",
        "                major += 1\n",
        "\n",
        "        return major_letter_grades[major] + minor_letter_grades[minor]\n",
        "\n",
        "\n",
        "############# END: DO NOT EDIT #############\n",
        "\n",
        "# Instructions: Modify the code below to give me an A!\n",
        "\n",
        "mumin = Student('Mumin Khan')\n",
        "\n",
        "mumin.assign_grade('HW_Unit_01', 80)\n",
        "mumin.assign_grade('HW_Unit_02', 85)\n",
        "mumin.assign_grade('HW_Unit_03', 100)\n",
        "mumin.assign_grade('HW_Unit_04', 100)\n",
        "mumin.assign_grade('HW_Unit_05', 95)\n",
        "mumin.assign_grade('HW_Unit_06', 90)\n",
        "mumin.assign_grade('HW_Unit_07', 90)\n",
        "mumin.assign_grade('HW_Unit_08', 85)\n",
        "mumin.assign_grade('HW_Unit_09', 100)\n",
        "mumin.assign_grade('HW_Unit_010', 100)\n",
        "mumin.assign_grade('HW_Unit_011', 100)\n",
        "mumin.assign_grade('HW_Unit_012', 100)\n",
        "mumin.assign_grade('HW_Unit_013', 100)\n",
        "mumin.assign_grade('HW_Unit_014', 100)\n",
        "mumin.assign_grade('HW_Unit_015', 100)\n",
        "mumin.assign_grade('HW_Unit_016', 100)\n",
        "\n",
        "print(mumin.current_grade_percent(), mumin.current_grade_letter())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mljSmBcYwvVs"
      },
      "source": [
        "### Submission Steps\n",
        "\n",
        "After completing this and following homeworks, you'll need to upload it to GitHub, then to GradeScope via GitHub. To do this:  \n",
        "\n",
        "1. Save your notebook locally (File > Save)\n",
        "2. Open a terminal and issue the following commands to add, commit, then push your work:\n",
        "    * `git add HW_Unit_01.ipynb`\n",
        "    * `git status`\n",
        "    * `git commit -m \"your message here\"`\n",
        "    * `git push`\n",
        "3. Navigate to github.com and view your completed notebook via your internet browser\n",
        "    * This ensures you've uploaded your work correctly. If it's not on GitHub.com, we can't see it.\n",
        "4. Navigate to gradescope.com and upload your assignment via GitHub\n",
        "\n",
        "If you have issues, please email us mids-python-instructors@googlegroups.com promptly for support."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "LlAD2g6hwvVs"
      },
      "source": [
        "## If you have feedback for this homework, please submit it using the link below:\n",
        "\n",
        "http://goo.gl/forms/74yCiQTf6k"
      ]
    }
  ],
  "metadata": {
    "anaconda-cloud": {},
    "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.12"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}