Lab 1 - Hello Python world!.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 1 - Hello Python world!\n",
    "*© 2020 Colin Conrad*\n",
    "\n",
    "Welcome to Week 1 of INFO 6270, Introduction to Data Science! If you got this far, it means that you have successfully launched and/or configured the Jupyter Notebook, likely using the Anaconda framework. Now that we are up and running, it is time to introduce you to some of the key concepts. As you know, much of the material that we will explored in the first 6 weeks has been covered by [Sweigart (2014)](https://automatetheboringstuff.com/). We are not going to rip off Sweigart's (rather excellent) book, but will build on many of the concepts he explores. These in-class exercises assume that you have read the recommended weekly readings.\n",
    "\n",
    "**This week, we will achieve the following objectives:**\n",
    "- Run basic Python scripts\n",
    "- Create Jupyter markdown code\n",
    "- Assign Python variables\n",
    "- Perform basic string manipulation\n",
    "- Debug Python code\n",
    "\n",
    "Weekly reading: Sweigart (2014) Ch. 0 and 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objective 1 - Run basic Python scripts\n",
    "As you know by now, Python is a high level programming language designed to emphasize readability. There are many reasons why someone might want to use Python, though the main reasons why we have opted to use Python in this course is that it has an extensive list of data science libraries. In fact, you are likely currently using Anaconda, a set of Python tools designed specifically for our use case. \n",
    "\n",
    "Traditionally, the very first thing that people do when learning a new programming language is learn how to print `hello world!`. In Python, this is really straight forward. Try running the following code by selecting the cell and clicking `Run` (alternatively, you can select `shift + enter`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prints 'hello world!'\n",
    "print('hello world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations, you probably just run your first Python script! This is a bigger accomplishment than you might think. You have taken your first steps into the wonderful world of code.\n",
    "\n",
    "Let's break down the concepts above a bit. First, you probably see the `#prints 'hello world!'` bit at the top. This is a comment. Comments are cool because they describe the code that you are executing, without themselves being executed. These are an essential part of writing good code because they tell other readers what the code does. It might seem silly at first, but once you start collaborating with other people you *will* understand the value of comments.\n",
    "\n",
    "The second thing worth discussing is the `print('hello world!')` bit. Python's `print()` function is a default function in Python which prints the string contained within the parentheses in the console. This is super handy when trying to debug code, and serves as a great starting point for our tutorial.\n",
    "\n",
    "### *Challenge Question 1*\n",
    "Can you write a script to print the phrase `INFO 6270 is awesome!`? Use the cell below to complete this task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prints 'INFO 6270 is awesome!'\n",
    "# [insert code here]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objective 2 - Create Jupyter markdown code\n",
    "Perhaps the biggest difference between today's tutorial and the course readings is that we are using a tool called Jupyter. This tool is an essential part of the data scientist's workbench, in part because it helps solve one of the biggest problems facing data scientists: *documentation*. Using Jupyter, we are able to effectively share code, but perhaps more importantly, to describe it. In many ways, the art of documentation is a subject in its own right, which we will touch on throughout this course.\n",
    "\n",
    "Jupyter notebooks are divided into a series of cells, which each contain code that can be written and transferred however you would like. You have already created and executed a cell in Challenge Question 1, when you created your first Python code. What is less obvious is that even this text is written in a cell! **Try double-clicking on this cell to see its code**. The difference between this cell and the previous is that this cell consists of documentation code, rather than Python.\n",
    "\n",
    "By default, Jupyter notebooks support creating documentation using a type of code called *Markdown*. Unlike Python, which is designed to process logic, Markdown is designed to facilitate the creation of text. In other words, Markdown is not a programming language; rather it is a *markup language*. More specifically, Markdown is a derivative of the hypertext markup language (a.k.a. HTML) and builds on HTML's fundamentals. If you have ever taken an introduction to webpage design course, markdown will be very familiar to you; you can even create markdown text using HTML code!\n",
    "\n",
    "We will not get into the details on how to create markdown files today, though we will slowly build this skill up as we make out way through the course. For now, the most important things that you need to know are that:\n",
    "\n",
    "1. You can specify the type of code that each cell belongs to using the dropdown box immediately to the right of the `Run` button.\n",
    "2. You can modify Markdown cells much like Python cells."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Challenge Question 2*\n",
    "Can you convert the following cell to a Markdown type?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Please convert me to Markdown! I am not Python code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objective 3 - Assign Python variables\n",
    "So far so good! Let's go back to Python and explore three fundamental concepts before calling it a day. As you likely read from [Sweigart (2014)](https://automatetheboringstuff.com/), programming languages can store data in the form of variables. In Python, variables can consist of many different types of data, such as: numbers (called 'variables'), decimals (called 'floats'), words (called 'strings), and more complex data structures which we will explore later. Using data stored in variables, we can create code that does virtually anything that we can imagine!\n",
    "\n",
    "Building on the main theme of this course, let's learn by doing. As of December 27th, there are 19 people registered for INFO 6270. If we wanted to save this number in a variable we could write the following Python code. Try running the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "enrollment = 19"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great work! Python has now saved a variable called `enrollment` and knows that its value is the interger `19`. Try running the code below to see if Python remembers the number of people enrolled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "enrollment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is good. However, this example is only somewhat accurate. One of the students in this class is actually aduiting the course, rather than taking it for credit. If we wanted to store this data properly, we might want to create three variables: one containing the enrollment for credit, one containing the audit enrollment, and one creating the total enrollment. Let's try expressing them using the code below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "credit_enrollment = 18 # the number taking the course for credit\n",
    "\n",
    "audit_enrollment  = 1 # the number auditing the course\n",
    "\n",
    "total_enrollment = credit_enrollment + audit_enrollment # the total number attending the course"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, if we wanted to retrieve any of these variables, you can do so any time in Jupyter. For exmaple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "credit_enrollment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "audit_enrollment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_enrollment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Awesome! It's also worth noting that the same concepts apply to all data that is saved in variables. If we wanted to save floats (decimals) or strings (text), we can likewise do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aplus_threshold = 90.0 #specifies the minimum grade for A+ in INFO 6270\n",
    "\n",
    "course_title = \"INFO 6270\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Challenge Question 3*\n",
    "In the cell below, create a variable called `first_name` that contains a string with your first name. We will return to this later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a variable that stores your first name\n",
    "# [insert code here]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objective 4 - Perform basic string manipulation\n",
    "One of the most interesting features of Python is the way that strings are stored. As mentioned earlier, strings consist of a series of characters that are often stored in a variable. Python has a number of default features that make it easy to change strings to suit our needs. For instance, Python treats strings as a series of elements (often called an 'array') which makes it easy to break them apart. If we wanted to retrieve the first character in the `course_title` string, we could easily retrieve it by using the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "course_title[0] #retrieves the second character in the string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a very handy feature for data scientists. You will often have to manage textual data and having the ability to easily separate strings will save you no only time, but also a great deal of grief. Let's use a more concrete example. If we wanted to only retrieve the course code in the `course_title` string, we could create a variable called `course_code` which consists of only the first four characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "course_code = course_title[0:4] #retrieves the first four characters in the course_title string\n",
    "\n",
    "course_code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python also comes with a number of default functions designed for string manupulation. We have already seen the `print()` function, which is one such example. Print typically prints the string values that are contained in the function's parentheses. Another handy function is `len()`, which gives us the length of a string. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(course_code) #specifies the number of characters in the string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another handy feature of Python is that strings can be easily concatenated. In Python, we can concatenate strings by simply using the `+` character. If we wanted to add the name of the course to the course title, we can easily do that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "course_title = course_title + \": Introduction to Data Science\" #adds the name to the course title\n",
    "\n",
    "print(course_title) #prints the new course title"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are just the basics of string manipulation, though we will regularly return to these concepts. Take some time to explore them, and do not hesitate to refer to the Python documentation if you get stuck!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Challenge Question 4*\n",
    "Earlier you created a `first_name` varible which stored your first name. Using this variable and the cell below, write code which does the following:\n",
    "- Creates a `last_name` variable containing your last name\n",
    "- Creates a `full_name` variable containing the concatenation of `first_name`and `last_name`.\n",
    "- Uses the `print()` function to print a string that contains your full name followed by 'is a student in INFO 6270' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sample output: \n",
    "# Colin Conrad is a student in INFO 6270\n",
    "# [insert code here]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objective 5 - Debug Python code\n",
    "There is one final concept that we should explore before calling it a day. It's one thing to create your own code and quite another to debug someone else's code. In INFO 6270, you will often be given scripts that are designed for a specific task, however they may not work properly. In the world of software, we refer to the process of fixing such code as 'debugging'. Fun fact, this term was coined by Grace Hopper, one of the grandparents of computer science, when she literally found an insect mucking around in her computer. \n",
    "\n",
    "Debugging can be an extremely frustrating process. For people who are not from technical backgrounds, this will feel tedious, and at times will make you feel inadequate. Believe it or not, technical people also frequently feel this way. The key is to stick with it and try to solve the problem by doing research and thinking critically about the problem. \n",
    "\n",
    "We have covered a lot of ground today, so I will leave you with these words of wisdom. Patience is the essential virtue of data science. If you take a patient approach, you will certainly be rewarded."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Challenge Question 5*\n",
    "This last challenge exercise combines many of the concepts explored thus far, while also introducing new challenges. There is a bug with this code that cannot be solved with the information given to you thus far. Consider reading more about data types (i.e. floats and strings) to solve this problem. In addition to broken code, this does not currently use the `input()` function, which it will need for the final product.\n",
    "\n",
    "Your answer should:\n",
    "- Use input() to take in a user-specified number of bonus points\n",
    "- Add the bonus points to the grade to get a calculated final grade\n",
    "- Print the string `\"Anon has a grade of XXX\"`, where XXX specifies 85.6 + your inputted bonus point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this code should print a string with a final grade that has the grade plus bonus points specified by a user with input()\n",
    "\n",
    "grade = 85.6 # a float type which needs to be converted to string\n",
    "\n",
    "student = \"Anon\" # the student whose grade we will specify\n",
    "\n",
    "print(student + \" has a grade of \" + grade) # print the final grade. This does not currently work and must be adapted."
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}