Exercise1_WelcomeToJupyter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Welcome to Jupyter\n",
    "\n",
    "### And welcome to your first exercise assignment!\n",
    "\n",
    "This is a Jupyter notebook, an online environment that supports these cells for text and other cells for writing code, like the next one below. We will use Jupyter notebooks for almost all of our assignments. This notebook is an exercise assignment and it is **due before class on Tuesday, Jan 21**. \n",
    "\n",
    "Corresponding textbook sections for this week are *Composing Programs* chapter 1: [section 1.1](http://composingprograms.com/pages/11-getting-started.html), [section 1.2](http://composingprograms.com/pages/12-elements-of-programming.html), and *Think Python* [chapter 1](http://greenteapress.com/thinkpython2/html/thinkpython2002.html), and [chapter 2](http://greenteapress.com/thinkpython2/html/thinkpython2003.html). Skip the sections on installing Python, unless you would like to know about how to install and run Python on your computer.\n",
    "\n",
    "A sacred tradition of computer scientists is to begin any new coding endeavor, especially in a new programming language, with a program that does nothing except say, \"Hello, World!\" \n",
    "\n",
    "Click on the next cell to highlight it, and then click on the \\[Run\\] button in the menu above, or *pro tip*: press `Shift + Enter` at the same time while the cell is highlighted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations, you ran your first CMSI 185 program! **Let's make it yours.** Say hello in real life to a person sitting next to you, and then edit the cell above to greet them by their name. Then go say hello to two more classmates, and make your program greet them too. This will result in three lines of code.\n",
    "\n",
    "### Nice!! So, what just happened?\n",
    "\n",
    "- Double-click on any markdown cell to edit it and take a few notes, or just listen and follow along\n",
    "    - When you're finished editing, run the cell to make it pretty again\n",
    "    - It could be helpful to compare notes with each other outside of class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "\n",
    "## \"*If Python be the food of love, code on.*\" – William Shakespeare\n",
    "\n",
    "This next code example is straight out of [Composing Programs](http://composingprograms.com/pages/11-getting-started.html), and gives Python a proper introduction by showing off several features of the language. Don't worry too much about syntax, the very strict grammar rules of programming languages, just yet. \n",
    "\n",
    "Replace each `...` with your own explanation of what each line is doing. In your comments, identify at least one of each: expression, statement, function, object, and name (also known as a variable).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# But first, comment.\n",
    "\n",
    "# Comments like this are used to explain our code,\n",
    "# especially in ways that can't be easily infered from the code itself.\n",
    "\n",
    "# ...\n",
    "from urllib.request import urlopen\n",
    "\n",
    "# ...\n",
    "shakespeare = urlopen('http://composingprograms.com/shakespeare.txt')\n",
    "\n",
    "# ...\n",
    "words = set(shakespeare.read().decode().split())\n",
    "\n",
    "# ...\n",
    "{w for w in words if len(w) == 6 and w[::-1] in words}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## Express yourself\n",
    "\n",
    "Let's look more closely at these *expressions*. Replace each `...` with an expression, and then run the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pick a number, any number\n",
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the number of seconds in the month of August\n",
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Is this legal? (just run the cell to see what happens)\n",
    "-1 - -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"I'd plead the fifth but we haven't learned fractions yet...\" - andertoons.com\n",
    "1/2 + 1/4 + 1/8 + 1/16 + 1/32 + 1/64 + 1/128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hmmm (note: this is a lame comment)\n",
    "100 ^ 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "The Python powers that be \n",
    "determined the ^ operator shall evaluate bit-wise calculations.\n",
    "For calculating powers, we use what's called function call notation.\n",
    "Actually for most calculations and evaluations we will use function calls.\n",
    "\n",
    "In other news, \n",
    "this is an acceptable form of multi-line commenting in Python, \n",
    "although using #s is most common.\n",
    "\"\"\"\n",
    "pow(100, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use a function call expression to compute the maximum (`max`) of the first number you chose and the number of seconds in August."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not all of the computations and evaluations we will ever want to do are built-in and ready to go. We will often import and/or create new functions. Run the cell below as is, notice what happens. Then uncomment the first line by deleting the `#` and run the cell again. `math` is a module containing several familiar mathematical functions. `from` and `import` have built-in meanings in Python, so we can use these words to write import statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#from math import sqrt\n",
    "sqrt(256)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also write expressions within expressions, called nested expressions. In the next cell, write an expression that calculates the maximum of ($100^{2}$, $2^{10}$, and the absolute value of $\\frac{-2020}{2}$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## Variables and statements\n",
    "\n",
    "A variable is a name that refers to a value. When we assign a value to a variable, we're writing an *assignment statement*. Jupyter code cells automatically output the value of the last line of the cell, which is why when you run this cell only one value is output. Use *print statements* to edit this code cell to make the output the value of `n * pi` on the first line, and the value of `3 * message` on the next line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# examples of assignment statements\n",
    "message = 'And now for something completely different'\n",
    "n = 17\n",
    "pi = 3.1415926535897932\n",
    "\n",
    "pi\n",
    "message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ... \n",
    "\n",
    "Use this markdown cell to explain in your own words how to name variables. What is allowed and not allowed? What is good practice? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## My types\n",
    "\n",
    "A few examples of values we've seen so far: \"Hello, World!\", 'http://composingprograms.com/shakespeare.txt', -1, 3.1415926535897932\n",
    "\n",
    "Each of these values has a type. We can use the call expression `type(...)` nested within a print statement to observe the type of each of these values. Use the next code cell to do evaluate and print the type of each of the above values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repeat the above process for each the following values: '1', 2, \"three\", max, \"pow\". \n",
    "Notice anything? *pro tip:* copy and paste your code from the above cell into the cell below and simply edit the arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What happens if...\n",
    "print(type(four))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In your own words, edit this markdown cell to describe why you think the output of the above cell is what it is.\n",
    "\n",
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}