week0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f9f1fd34",
   "metadata": {},
   "source": [
    "# Practical Python: Week 0\n",
    "\n",
    "<img width = \"300\" src=\"./images/hazel.png\" align=\"right\" style=\"padding-left:10px\">\n",
    "\n",
    "Congratulations! you have cloned the Practical Python repository and successfully fired up your first course notebook!. You are well on your way to running other people's code, writing your own code to analyze data, and making notebooks to communicate your results to others. \n",
    "\n",
    "What will we do this week? Since you have already done a *lot* of of practical work just by setting up miniconda and Jupyter, this pre-class is going to be pretty relaxed: a little tour of programming, Python, and Jupyter. The hardest part is over: you've gotten your environment set up!\n",
    "\n",
    "<img align=\"left\" width = \"100\" src=\"./images/bike_rider.jpg\" style=\"padding-right:20px;padding-top:15px\">\n",
    "\n",
    "Note this class is meant for *absolute beginners*, and this particular notebook is a  conversational introduction to what will soon become a fairly fast-paced crash course in Python over the next four weeks. If you already have experience programming, the material in this notebook will probably seem very basic. If so, feel free to skip or skim ahead to sections that interest you, such as how to work with Jupyter notebooks: there are links in the Table of Contents.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e65becb3",
   "metadata": {},
   "source": [
    "<a id = \"toc\"></a>\n",
    "## Table of contents\n",
    "[0. What is a computer program?](#computer_program)   \n",
    "[1. What is Python?](#python)    \n",
    "[2. Soft's a Jupyter notebook and why are we using them?](#jupyter)    \n",
    "[4. How are the notebooks organized?](#notebook_anatomy)    \n",
    "[5. Dualing modes: entering code and text into your notebook](#code_and_markdown)    \n",
    "[6. To learn more](#more)    \n",
    "[7. On to week 1!](#week1)    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a60f5ac",
   "metadata": {},
   "source": [
    "<a id=\"computer_program\"></a>\n",
    "# 0. What is a computer program?\n",
    "<img align = \"right\" width = \"400\" src=\"./images/super_fort.jpg\" style=\"padding-left:15px\">\n",
    "Computer programs are recipes you write for you computer to follow: they instruct your computer to carry out some task. Even video games like Fortnight (developed in Cary, NC) are really just complicated recipes -- or sets of instructions -- that tell the computer what to show on the screen in response to what you do on your controller.<br></br>\n",
    "\n",
    "\n",
    "*Coding* is just another word for 'writing a computer program', and *code* is another word for the instructions themselves. Programs are usually just a bunch of lines of text. There are literally hundreds of different programming languages that consist of different rules for how to tell the computer what to do. \n",
    "\n",
    "Some are very easy to learn because they let you write code by dragging pictures around on a screen, so kids can literally code before they can read (Hopscotch and Scratch). Some are extremely hard to understand. For instance, *machine code* is code that is typically written in binary digits: it is perfect for the computer, but impossible for untrained humans to read. \n",
    "\n",
    "Between these extremes is where most programmers live, in the world of text-based programming languages that use ordinary words like *and*, *if*, and *or* to tell the computer what to do. Python is one such language. It is extremely popular right now partly because it is easy to learn compared to other languages. For instance, the following line is a Python program:\n",
    "\n",
    "    22+2\n",
    "\n",
    "This instructs the computer to add two numbers, and is something you can easily understand. Indeed, we can think of Python as an infinitely scalable, glorified calculator. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "231a384b",
   "metadata": {},
   "source": [
    "<a id =\"python\"></a>\n",
    "[Back to Table of Contents](#toc)    \n",
    "\n",
    "# 1. How does Python work?\n",
    "Python is a glorified calculator that can scale up to handle some of the most complicated tasks you can throw at it. How do Python programs work? At a cartoon level, it is pretty simple: you have some code, such as the expression `(2+8)/2`, and you send it off to the *Python interpreter* which then reads this code and produces the appropriate output (`5`):\n",
    "\n",
    "<img align = \"center\" width = \"600\" src=\"./images/python_interpreter.jpg\">\n",
    "\n",
    "You don't need to worry much about the Python interpreter. It is basically the brains of Python -- it takes in the code, reads it, and then carries out the instructions you provided. As you might guess, the Python interpreter is itself a program and is written in a different programming language (one that runs really fast)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8b8e48a",
   "metadata": {},
   "source": [
    "<a id = \"ides\"></a>\n",
    "[Back to Table of Contents](#toc)    \n",
    "# 2. What software do people use to write Python programs?\n",
    "<img align = \"right\" width=\"125\" src=\"./images/spyder.png\">\n",
    "\n",
    "There are *many* different programs we can use to write Python code.<br></br>\n",
    "\n",
    "At the simplest, you could code by using your computer's built-in text editor to write programs, and then send this code off to the Python interpreter. At the other extreme, there are programs known as *IDEs* (Integrated Development Environments). IDEs are fancy software platforms that let you do much more than write code. IDEs include *debuggers* to help you identify and remove errrors; they often include connections to code repositories to make it easier to  publish your code to places like Github for other people to download and use your code. If you are curious about Python IDEs, you can look up some of the more popular ones such as *PyCharm*, *Visual Studio Code*, *Spyder*, *Eric*, *IDLE*, and more."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a75e390f",
   "metadata": {},
   "source": [
    "<a id=\"jupyter\"></a>\n",
    "[Back to Table of Contents](#toc)    \n",
    "# 3. What's a Jupyter notebook and why are we using them?\n",
    "<img src=\"./images/jupiter.png\" align=\"right\" width=\"155\" style=\"padding-left:15px\">\n",
    "\n",
    "While an Integrated Development Environment (IDE) is meant for writing code with blazing efficiency, Jupyter notebooks are more conducive for *learning* to code, and communicating scientific ideas. A Jupyter notebook combines the ability to run Python code with the ability to display nicely formatted text/images/equations so people can more readily understand what you are trying to say. You are reading one right now.\n",
    "\n",
    "Note that while Jupyter notebooks are usually associated with Python, the name 'Jupyter' is formed by combining the names of three popular programming languages: **Ju**lia, **Pyt**hon, and **R**. One nice thing about Jupyter notebooks is that you can use them to program in many different languages. \n",
    "\n",
    "Before Jupyter, when people learned Python, the question, \"What IDE should I use?\" was a big controversial question. Nowadays, it has become simplified because people have naturally gravited toward Jupyter notebooks because of their relative ease of use and nice formatting. \n",
    "\n",
    "This move toward Jupyter has not been just for the neophyte: Jupyter has become the common language for communication among Python programmers. New books and software packages now demo their work using Jupyter notebooks, because it is just assumed that everyone reading will be comfortable learning using these tools. Also, all three of the cloud computing services (Amazon Web Services, Google Colabs, and Microsoft Azure) use some version of Jupyter notebooks for cloud-based computing. So if you can read and use Jupyter notebooks, then you understand the most cutting edge tool being used for generating large-scale analysis infrastructure in the cloud.\n",
    "\n",
    "In the rest of this lesson we will have a brief overview of Jupyter notebooks: just enough to get us moving along in subsequent classes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dd1e279",
   "metadata": {},
   "source": [
    "<a id=\"notebook_anatomy\"></a>\n",
    "[Back to Table of Contents](#toc)    \n",
    "\n",
    "# 4. Anatomy of a Jupyter notebook\n",
    "Take a look around the screen you currently have open, in particular the top. You will notice a bunch of little widgets up there that let you control what's going on in your notebook. It should look something like this:\n",
    "\n",
    "<img align = \"center\" width = \"800\" src=\"./images/jupyter_notebook_blank.jpg\" style=\"padding:10px\">\n",
    "\n",
    "At the top left, next to the Jupyter logo, you will find the *name* of the current notebook you are working in. This one should say `week0`. Below that title is the *menu bar* which contains a bunch of dropdown menus, or lists of items that will show when you click on them. \n",
    "\n",
    "For instance, if you click on `File`, the first option is to create a `New notebook`, among many other things (such as `rename`). If you click on `Help` you will see a useful list of help options you can click on (like Jupyter keyboard shortcuts).\n",
    "\n",
    "One important keyboard shortcut is for adding new cells to your notebook: you can add a new cell above the currently selected cell with `esc-a`, or below the currently selected cell with `esc-b`. You can also insert cells using the `Insert` selection in the Menu bar.\n",
    "\n",
    "Below the Menu Bar is the *Toolbar*, which has a bunch of little icons (pictures) that you can click on to do things. For instance, the little floppy disc icon on the left lets you save your progress. The scissor icon will remove a cell. The button that says *Run* will run the code in a cell (or format and display the markdown). If you hover your mouse cursor over an icon for a bit, a little text description of what will happen if you click will appear.\n",
    "\n",
    "What about the dropdown menu that says 'Code' in the picture (and in your current window probably says 'Markdown'?). This is connected to the part of the window below the Toolbar: the big blank space below that says 'Cell' that is highlighted in blue in the figure. It is so important,  we will devote all of the following section to it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "def8f329",
   "metadata": {},
   "source": [
    "<a id =\"code_and_markdown\"></a>\n",
    "[Back to Table of Contents](#toc)    \n",
    "\n",
    "# 5. Dualing modes: code and markdown cells\n",
    "Beneath all the menus and toolbars in Jupyter are where the magic happens: the *cells*. \n",
    "\n",
    "The cells trade on an ingenious, and sometimes confusing, use of *two modes of entering information*. One, the **code** mode, lets you enter Python code to send to the interpreter. A second, **markdown** mode lets you enter formatted text meant to be read by humans like you are reading now. (There are other modes, but we will ignore them). When you are done entering information in a cell, press `SHIFT-ENTER` to see the formatted markdown text or send it to the interpreter.\n",
    "\n",
    ">  **Note**: You can switch between markdown/code modes in two ways, either using the dropdown menu in the toolbar, or using keyboard shortcuts (`ctrl-m` puts you in markdown mode; `ctrl-y` puts you in code mode).\n",
    "\n",
    "You are currently reading text that has been written in markdown and processed by Jupyter to display for human consumption. To tell Jupyter whether you are entering code or markdown in a cell, you can just check out dropdown menu above. If you have the current cell highlighted in the notebook you are reading, it will say `Markdown` in it. Let's talk more about markdown."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cba798a2",
   "metadata": {},
   "source": [
    "## 5A. Markdown: A very brief introduction\n",
    "Markdown is a simple, easy, powerful way to format documents. It has become ubiquitous because it lets us talk to each other using nicely formatted text/images/equations interspersed with code. In addition to Jupyter notebooks, it is automatically displayed at Github on readme files (in `readme.md` files the `md` stands for 'markdown'). \n",
    "\n",
    "A few tricks you will use a lot for formatting markdown include:\n",
    "\n",
    "- Pound signs (`#`) for headings: Enter a single pound sign (`#`) followed by a space, followed by the text, to make a large title. To make subheadings, add more pound signs (so use `##` to make a subheading).\n",
    "- Italics: put an asterisk `*` before and after the word, so *this* should be in italics.\n",
    "- Bold: put double asterisks `**`  before and after the word, so **this** should be bold.\n",
    "- Numbered lists: just write numbers with periods after them, a space, and then the text. \n",
    "- Bullet lists: for lists like the one you are reading now just enumerate each item with a dash followed by a space.\n",
    "\n",
    "Note you can click on any of the cells in this document to see how it was formatted, including this one. To get it back to the formatted state, either click `Run` in the Toolbar, or `SHIFT-ENTER` on your keyboard.\n",
    "\n",
    "You don't need to know much about markdown to use Jupyter. Basically just start typing and practice, and if you get stuck Google what you need: that's what everyone does. For more on markdown, see the suggested reading in [Section 6](#more)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfd05a01",
   "metadata": {},
   "source": [
    "### Get some practice!\n",
    "<img align = \"right\" width = \"150\" src=\"./images/sandbox.png\" style=\"padding:5px\">\n",
    "Why don't you practice writing your own markdown?\n",
    "\n",
    "In the following cell, write some markdown that contains a single title (`#`), a numbered list, and some text with bold and italicized words in it. When you are done, display the formatted text by by clicking on `Run` in the Toolbar, or `shift-enter` on your keyboard."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea102b6c",
   "metadata": {},
   "source": [
    "    ---> \n",
    "\n",
    "\n",
    "    double click here and replace me with some practice markdown  \n",
    "\n",
    "\n",
    "    <---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "674556e5",
   "metadata": {},
   "source": [
    "I encourage you to play with markdown, adding new cells and content whenever you see fit to take notes (and and write code) during this course. That is what it is here for, and how you will realize the full potential of Jupyter for learning Python.\n",
    "\n",
    "Remember you can add new cells with `ctrl-a` or `ctrl-b` or by clicking `Insert` in the menu above."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01e804c7",
   "metadata": {},
   "source": [
    "## 5B: Code mode\n",
    "In addition to using markdown mode to write formatted text, a cell can be run in *code* mode. When a cell is in code mode, Jupyter will send each line to the Python interpreter, and return the output.\n",
    "\n",
    "As an exercise, try entering a mathematical expression in the following cell and then hit Run (or `shift-enter`). Make sure the cell is in Code mode when you do or else it will just print it out as text/markdown):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "01f64a93",
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# double click here and  replace me with some math like 1/2\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46f1ce81",
   "metadata": {},
   "source": [
    "Beause the point of the rest of all these classes is to learn Python code, we are not going to spend more time with this now. I just want you to understand the distinction between markdown/code modes. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7586ebb",
   "metadata": {},
   "source": [
    "<a id=\"more\"></a>\n",
    "[Back to Table of Contents](#toc)    \n",
    "# 6. To learn more\n",
    "We could spend multiple classes going over Jupyter notebooks and fun things to do with them. But the main goal here is to set it up as a tool to get Python running, and to learn some *minimal* markdown skills so you can take some notes in Jupyter when you need to. \n",
    "\n",
    "There are lots of great resources online for learning more about markdown and Jupyter:\n",
    "\n",
    "- [Realpython intro to Jupyter](https://realpython.com/jupyter-notebook-introduction/): In general, RealPython is a great online resources for learning about Python, and this is a nice introduction to Jupyter. \n",
    "- [Intro to jupyter](https://github.com/ipython/ipython-in-depth/blob/7e5ce96cc9251083979efdfc393425f1229a4a68/examples/Notebook/Notebook%20Basics.ipynb): Introduction in a Jupyter notebook, including a more in-depth overview of keyboard shortcuts and such.\n",
    "- [Markdown guide](https://www.markdownguide.org/basic-syntax/): If you want to learn a lot more Markdown basics, there are tons of web sites with detailed instructions and tutorials. I really like this guide for its no-nonsense style."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7abbd62c",
   "metadata": {},
   "source": [
    "<a id = \"week1\"></a>\n",
    "[Back to Table of Contents](#toc)    \n",
    "\n",
    "# 7. On to Week 1!\n",
    "You have done a ton of work, from installing Python and Jupyter to learning about how Jupyter notebooks work. Once you feel comfortable with all the material in this notebook, you should move on to the material in Week 1 proper. There, we will start to cover the basics of Python.\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7455de34",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}