py4e_ch2_varaibles_and_types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Py4E: Ch 2: Variables, expressions, and statements\n",
    "\n",
    "## A note on change in format\n",
    "\n",
    "The previous sections of this website were written in Markdown and converted to static HTML pages to be served via github with [Jekyll](https://jekyllrb.com/), a [Ruby](https://www.ruby-lang.org/en/)-based framework, using the [Documentation theme](https://idratherbewriting.com/documentation-theme-jekyll/). \n",
    "\n",
    "For the Bash section, that worked Ok, and there are not great tools to mix interactive code demonstration with nicely formatted descriptions on the web.\n",
    "\n",
    "As we move into the Python section of the course, there is a tool made for this: Jupyter Notebooks. As such, most of the rest of the course content will be presented as Jupyter Notebooks. GitHub does a decent job of rendering static versions of notebooks on the web (though it does fail at times), but one neat thing about notebooks is that they can remain fully interactive for you in the right environment. \n",
    "\n",
    "### Some methods of running the notebooks interactively:\n",
    "\n",
    "* Clone the [repository](https://github.com/comptoolsres/Jupyter_content) to your space on HiPerGator, log into [JupyterHub](https://jhub.rc.ufl.edu/), open the notebooks and play with the code.\n",
    "  * One advantage of this is that you can run `git pull` periodically to get updated content.\n",
    "\n",
    "* The Google Colaboratory runs Notebooks. You can [open this notebook here](https://colab.research.google.com/github/comptoolsres/Jupyter_content/blob/master/py4e_ch2_varaibles_and_types.ipynb) or load the whole repository from the File menu > Open Notebook, select the GitHub tab and paste the URL to the repository: https://github.com/comptoolsres/Jupyter_content \n",
    "  * This will work for most of the things we do in class and may be easier than using HiPerGator for some. There are a few data files too large for the git repo, but I try to provide another source to download those.\n",
    "\n",
    "* View the notebooks in Binder: [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/comptoolsres/Jupyter_content.git/main)\n",
    "  *Binder can take a minute or two to start up, which can get a bit frustrating at times.\n",
    "\n",
    "* VSCode can run Jupyter Notebooks, [either on your own computer](https://code.visualstudio.com/docs/python/jupyter-support) or even remotely on HiPerGator\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Py4E Ch 2: Variables, expressions, and statements \n",
    "\n",
    "### 2.1 Values and types\n",
    "\n",
    "#### Implicit vs explicit typing\n",
    "Like Bash, Pyhton uses *implicit typing* of variables. This is also sometimes called \"duck typing\". That is, if it looks like an integer, it's an integer. Variables are typed based on the values they store at the time.\n",
    "\n",
    "The oposite of implicit typing is *explicit typing* where you, as the coder, must declare--when you define the variable--what type of values it will hold. C, C++ and others rely on explicit typing--this tends to be the case for compiled programs as the machine code needs to be compiled to properly store the value before the data are present. This forces coders to be more explicit about what they plan to do with a variable, but can also be limiting when you might want to not be explicit ahead of time.\n",
    "\n",
    "Implicit typing is handy for programmers because you don't need to think about what type of data the variable will hold...except that you kind of do, because different types do different things when you operate on them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "<class 'str'>\n<class 'int'>\n<class 'float'>\n"
    }
   ],
   "source": [
    "# Getting the type of a value\n",
    "print(type('Hello, World!'))\n",
    "print(type(17))\n",
    "print(type(3.2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some common variable types and examples of the data they correspond to:\n",
    "\n",
    "Type |\tExample\n",
    "-----|---------\n",
    "Integer\t|42\n",
    "Float (real)|\t3.14\n",
    "Boolean\t|True\n",
    "String\t|Hello\n",
    "List\t|[1,4,\"text\",5]\n",
    "Tuple\t|(42,\"Answer\")\n",
    "Dictionary |\t{\"Name\" : \"Matt\", \"Fingers\" : 10}\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Variables\n",
    "\n",
    "Notice the difference between how variables are created and referenced in Bash and Python.\n",
    "\n",
    "On the creation side, spacing is not as important as it was in Bash (remember it didn't work if there were spaces on either side of the `=` sign). The Python convention is to put spaces on both sides of the `=` singn, but it will work with or without them.\n",
    "\n",
    "In Bash, we assigned a value with something like `x=7` and then referenced the variable (i.e. get its current value) with something like `echo $x`--adding the `$` before the variable name. Most programming languages use some character, often the `$`, before variable names to help differentiate variables from other text. Python is different in that it does not use any special characters. While this can be nice, and aids readability, as we will see, this can create other problems. A good text editor with syntax coloring will help you out here too!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# From 2.2 Variables; p. 20 of Py4E\n",
    "message = 'And now for something completely different'\n",
    "n = 17\n",
    "pi = 3.1415926535897931"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "And now for something completely different\n17\nPi is: 3.141592653589793\n"
    }
   ],
   "source": [
    "print(message)\n",
    "print(n)\n",
    "print (\"Pi is:\", pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As noted above, with nothing to specify something as a variable, we do need to make some adjustments. In Bash, we could have done something like:\n",
    "\n",
    "```Bash\n",
    "[magitz@login4 ~]$ pi=3.14\n",
    "[magitz@login4 ~]$ echo \"Pi is: $pi\"\n",
    "Pi is: 3.14\n",
    "```\n",
    "\n",
    "Let's try that in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Pi is: pi\n"
    }
   ],
   "source": [
    "print(\"Pi is: pi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not quite what we were after! There are a number of ways of getting what we want and there have even been some recently added methods for newer versions of Python. Below are three (of several) methods and in the following block how tht is extended to add additional variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Pis is: 3.141592653589793\nPi is: 3.141593\nPi is: 3.141592653589793\n"
    }
   ],
   "source": [
    "print(\"Pis is:\", pi)  # Maybe the most traditional way. Can get complex with many variables\n",
    "print(\"Pi is: %s\" %(pi)) # Format specifiers: each specifier is replaced with the value of the variables in the order listed at the end.  \n",
    "print(f\"Pi is: {pi}\")  # The new \"f-strings\" format in Python 3.6 and above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Pis is: 3.141592653589793 . The value of n is: 17\nPi is: 3.141592653589793. The value of n is: 17\nPi is: 3.141592653589793. The value of n is: 17\n"
    }
   ],
   "source": [
    "# Adding additional information to the print statements\n",
    "# for each format shown in the cell above\n",
    "print(\"Pis is:\", pi, \". The value of n is:\", n)\n",
    "print(\"Pi is: %s. The value of n is: %d\" %(pi, n))\n",
    "print(f\"Pi is: {pi}. The value of n is: {n}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I will generally try to use the f-strings format for print statements as I think it is the most clear and best habit to get into using.\n",
    "\n",
    "## 2.3 Variable names and keywords\n",
    "\n",
    "There are many (conflicting) opinions on variable naming. Consistency wins, but the [PEP8 Style Guide](https://www.python.org/dev/peps/pep-0008/) says that variable and function names should be `lower_case_with_underscores` connecting multple words.\n",
    "\n",
    "Keep reading through the chapter, lots of good information...\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.10 Asking the user for input\n",
    "\n",
    "We saw how to get input in Bash, here are some examples using the input() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "This is a test\n"
    }
   ],
   "source": [
    "inp=input()\n",
    "print(inp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Hi Matt , nice to meet you!\n"
    }
   ],
   "source": [
    "\n",
    "name=input(\"What is your name?\\n\")\n",
    "print(\"Hi\", name,\", nice to meet you!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the spaces that `print()` puts between the things we told it to  (the space between the name and the comma). That can also be controlled (we just need to put spaces where we do want them):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Hi Matt, nice to meet you!\n"
    }
   ],
   "source": [
    "name=input(\"What is your name?\\n\")\n",
    "print(\"Hi \", name,\", nice to meet you!\", sep=\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "17"
     },
     "metadata": {},
     "execution_count": 13
    }
   ],
   "source": [
    "prompt = 'What...is the airspeed velocity of an unladen swallow?\\n'\n",
    "speed = input(prompt)\n",
    "int(speed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Your turn...\n",
    "In a group, work on **Exercise 3** at the end of Chapter 2 of Py4E (p. 30 in the PDF).\n",
    "\n",
    "If you finish that, do **Exercise 5**."
   ]
  }
 ],
 "metadata": {
  "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-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python37364bitprogramdatavirtualenve052a15fdf474e65bee0bc256eac07a5",
   "display_name": "Python 3.7.3 64-bit ('ProgramData': virtualenv)"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}