nsc1002_wk02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c6d07fd7-fd1c-44d3-9c11-3cb09971d83a",
   "metadata": {},
   "source": [
    "# Worksheet 2 - Data Types & Conditionals\n",
    "\n",
    "Previously you learned...\n",
    "- Why computer programming is important\n",
    "- That a computer programming language is used to communicate human instructions to computers\n",
    "- Python is an interpreted computer programming language and that throughout this course we'll be using the Anaconda installation of Python\n",
    "- How to find and write a basic program using Jupyter\n",
    "- Basic data types (int, float, str, bool)\n",
    "\n",
    "By the end of this session, you will...\n",
    "- Know more about data types, including _strings_, _lists_ and _tuples_.\n",
    "- Know what mutable/immutable data is\n",
    "- Understand what a conditional is (if statement) and use in a program\n",
    "- Use matplotlib's plot function to display data\n",
    "\n",
    "If you have any questions during this session please do not hesitate to ask one of the demonstrators. You should ensure that you have completed all exercises before the next workshop.\n",
    "\n",
    "___\n",
    "\n",
    "## Data Types continued: lists, strings, and tuples\n",
    "In the last workshop we discussed different data types (int, float, bool, str). In this workshop we'll discuss more about data types including more about strings, lists, tuples.\n",
    "\n",
    "### What are Lists?\n",
    "Lists are arrangements of values that are identified with an index. For example, in the list `[-2., 'cat', 42]`, The first value is identified with the index 0, the second value, 'cat', is identified with the index 1, and the last value, 42, is identified with the index 2. Run the following code and look at the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8da15d41-f795-45e8-9b10-4cd26baac2f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2.72\n",
      "-3.14\n",
      "42.0\n"
     ]
    }
   ],
   "source": [
    "A = [-2.72, -3.14, 42.]\n",
    "print(A[0])\n",
    "print(A[1])\n",
    "print(A[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e68d7bca-ddbf-42fe-8935-0b6f781a765c",
   "metadata": {},
   "source": [
    "Why is a list useful? Lists can allow us to easily create a plot using Python's built-in plotting package pyplot. Pyplot is a collection of functions that allows a user to interface with computer graphics. We will be writing simple programs to use plotting thoughout this course. In order to make use of the plotting package we must import it into our python script with the line `import matplotlib.pyplot as plt`. This method will be used again to import other packages later in the course -- you only need to do this once per notebook we tend to put import statements at the start of our work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "980ffbf9-5a91-4bb3-9b6e-37b1181eb9e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt     # To save typing the full package name we can create a shortcut called plt\n",
    "\n",
    "# Create two lists, plot them.\n",
    "x = [1, 2, 3, 4]\n",
    "y = [1, 7, 3, 5]\n",
    "plt.plot(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b954a5c0-b58f-42aa-b2d9-4836474504c0",
   "metadata": {},
   "source": [
    "Examine the use of the two lists in the plot function. The figure shows the connection between the elements in the list and the graph pyplot produces. Change the 4 in the first list to 22 and rerun your program. What happens? Change the 7 in the second list to 14 and see what happens. The function plot takes 2 lists, the first is a list of values that corresponds to the horizontal axes, and the second list corresponds to the vertical axes. Type 'Python pyplot syntax' into a search engine to see a list of all the possible options for the plot function.\n",
    "\n",
    "The figure below shows how the plot was created from the lists provided:\n",
    "\n",
    "![](nsc1004_wk2_fig1.png \"Figure 1\")\n",
    "\n",
    "### What are Strings?\n",
    "Like lists, strings (and tuples) are ordered sequences of elements. Strings can be represented by single or double quotes. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8275b5b1-4002-4f8e-a1ed-88e030e3b3fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "string1 = 'Minerva'\n",
    "string2 = 'Bridget'\n",
    "\n",
    "# You can do operations on strings\n",
    "string3 = string1 + string2\n",
    "string4 = 4 * string1 + 3 * string2\n",
    "string5 = string1 + string2\n",
    "print(string5)\n",
    "\n",
    "string4 = 4 * string1 + 3 * string2\n",
    "print(string4)\n",
    "\n",
    "# You can find out how long a string is using len()\n",
    "print('length of string1 =', len(string1))\n",
    "print('length of string4 =', len(string4))\n",
    "\n",
    "# You can extract individual characters from a string. Notice the use of []\n",
    "# rather than ()\n",
    "print(string4[0])\n",
    "print(string4[5])\n",
    "\n",
    "# You can do 'slicing' on strings\n",
    "string6 = string4[0:4]\n",
    "print(string6)\n",
    "\n",
    "num_chars_string1 = len(string1)\n",
    "string7 = string5[0:num_chars_string1]\n",
    "print(string7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc10ff8e-8633-4f13-80de-8e27d1c85077",
   "metadata": {},
   "source": [
    "You can perform operations on strings. You can do a web search on \"Common string operations Python\" and find many different operations such as `string.digits`, `string.uppercase`, `string.letters`, `string.index`. These operations can be performed by using: `string.<operation>` where operation is any of the above. For example,\n",
    "```python\n",
    "string1 = 'Minerva'\n",
    "string2 = 'erv'\n",
    "print(string1.index(string2))\n",
    "```\n",
    "will produce the output 3.\n",
    "\n",
    "### What are tuples?\n",
    "Tuples, like strings and lists are also ordered sequences of elements. The difference between tuples and lists are that tuples, once assigned, cannot be changed, unlike lists. Tuples use round brackets and lists use square brackets. In Python, objects whose data can be changed are called mutable and objects whose data cannot be changed are called immutable. Tuples are immutable, while lists are mutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b4b5bd5-932d-4a58-9566-eaf2967f0531",
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1 = (1, 'Minerva', 'cat', 56)\n",
    "tuple2 = ('Bridget', 'David', 24.57)\n",
    "tuple3 = (46, )\n",
    "\n",
    "print(tuple1)\n",
    "print(tuple2)\n",
    "print(tuple3)\n",
    "print(tuple1[1])\n",
    "print(tuple1[3])\n",
    "\n",
    "# Like strings tuples can be concatenated, sliced and indexed\n",
    "print(tuple1 + tuple2)\n",
    "print(len(tuple1))\n",
    "print(len(tuple1 + tuple2))\n",
    "\n",
    "# Multiplying makes copies\n",
    "print(5 * tuple1)\n",
    "print(tuple1[0])\n",
    "print(tuple3[0])\n",
    "print(tuple1[1:3])\n",
    "print((tuple1 + tuple2)[3:7])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60d5f728-fdde-4927-a597-22c390d7f330",
   "metadata": {},
   "source": [
    "### Conditional Statements (if statements)\n",
    "\n",
    "Conditionals are blocks of code that make cause a code to branch. A conditional statement has three parts:\n",
    "1. A test that evaluates to either true or false\n",
    "2. A block of code that is executed if the test evaluates to true\n",
    "3. Another (optional) block of code that is executed if the test evaluates to false\n",
    "\n",
    "In the lecture we talked about conditionals (also called if statement). Here is some information about them. The structure of an if statement looks like this:\n",
    "```python\n",
    "if <conditional statement>:\n",
    "    Do Something\n",
    "elif <conditional statement>:\n",
    "    Do some other thing\n",
    "else:\n",
    "    Do something different still\n",
    "pass\n",
    "# The pass statement does nothing and is optional but can\n",
    "# be a useful visual marker for the end of the conditional\n",
    "Rest of the code continues here\n",
    "```\n",
    "\n",
    "The overall structure is 'if, elif, else'. The elif and else statements are optional and not always needed. Remember, you must indent the contents of the if statements by 4 spaces! We also discussed the following relational operators used in conditional statements: `==, >, <, !=, >=, <=` and also logicals like **and**, **or**, and **not** (for example if `a != b` or `b == c`). We discussed a program that calculated the relationship between two integers (i.e., equal, greater than or less than). The code can be\n",
    "found below:\n",
    "```python\n",
    "if x == y:\n",
    "    print('x equals y')\n",
    "else:\n",
    "    if x > y:\n",
    "        print('x is greater than y')\n",
    "    else:\n",
    "        print('x less than y')\n",
    "```\n",
    "\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a677990c-e379-48cd-bd6f-ead424e5082c",
   "metadata": {},
   "source": [
    "## Exercise 1\n",
    "\n",
    "Use the code above and intialise the values of x to 5 and y to 10. Run the code and note the result.\n",
    "\n",
    "Introduce a syntax error by removing one of the ':' -- do you understand the error message?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca3417ca-d058-4abc-9488-74058df9b070",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a7e90283-c9f5-4e12-94da-f28fe4e6b0b4",
   "metadata": {},
   "source": [
    "## Exercise 2\n",
    "Write a new program that prints the larger of two integers (or if they are equal)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d998ec7-9281-4283-afe5-c59a1f479efe",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "22943ac4-96f8-4191-8c55-f161be619413",
   "metadata": {},
   "source": [
    "## Exercise 3\n",
    "Write a new program that prints the largest of four integers (or if they all equal one another)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be79b15d-28fd-44b2-a771-29c4f4795e3f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3a2c64a1-0a25-4b0b-b160-f30c7199015a",
   "metadata": {},
   "source": [
    "## Exercise 4\n",
    "Write a new program that prints the first and last element of each list:\n",
    "```python\n",
    "list1 = [1, 2, 3, 4, 5, 6, 7]\n",
    "list2 = [16, 2, 43, 22., .11116, 2./3., 72.]\n",
    "list3 = ['a', 'b', '63']\n",
    "list4 = ['abcde', '54']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d796607-488b-4e5b-8f04-d7efd383e7fa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b0972daa-b3f0-415b-8343-cb14c43a2bb2",
   "metadata": {},
   "source": [
    "## Exercise 5\n",
    "Create the following two variables and make use of the supplied code below:\n",
    "```python\n",
    "string1 = 'abcdefghijklmnopqrstuvwzyz'\n",
    "string3 = 'hij'\n",
    "```\n",
    "\n",
    "1. Modify the code to check if the 3rd element in each string is a ‘j'. If it is, print out the entire string.\n",
    "2. Modify the code to find the index in string1 where the string ‘hij' of string 3 begins.\n",
    "3. Modify the code to create a new string that represents the alphabet minus “hij”. Though strings are immutable you can form new ones using indexing. Your program should look something like the program below (N.B.: The code below contains some intentional errors!)\n",
    "4. Compute another new string that does not include “hij” or “opq”.\n",
    "\n",
    "Hint: You will find conditionals useful.\n",
    "\n",
    "Hint: use the function “index”. If you don't know the syntax look it up online!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "891af163-d672-4836-89dc-88f03ce04dd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "This program experiments with strings. However, it has some errors in it!!\n",
    "@author: Beth Wingate, modified by G. Vallis\n",
    "Date: 9 November, 2018\n",
    "\"\"\"\n",
    "string1 = 'abcdefghijklmnopqrstuvwzyz'\n",
    "string3 = 'hij'\n",
    "# Experiment with strings\n",
    "# print out each letter of string3\n",
    "print('first letter of string3 ', string3[1])\n",
    "print('second letter of string3 ', string3[2])\n",
    "print('third letter of string3 ', string3[3])\n",
    "# At which index in string1 does the sequence 'hij' (defined in string3) begin?\n",
    "hij_index = string1.index(string2)\n",
    "print(hijindex)\n",
    "# Form a new string that doesn't contain 'hij'.\n",
    "newstring = string"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87230b22-fa1f-4120-9a6e-3d3046bd92d7",
   "metadata": {},
   "source": [
    "## Exercise 6\n",
    "The roots of a quadratic $ax^2 + bx + c = 0$ are be given by the equation\n",
    "$$x = \\frac{-b\\pm\\sqrt{b^2-4ac}}{2a}$$\n",
    "Write a program that calculates the roots of a quadratic using this formula.\n",
    "\n",
    "Hint: You will have to use a conditional statement to deal with what happens if there are no real roots or the roots are equal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7aa8915-001e-4daf-ae38-86ddded0485f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e3a34307-76d7-4f55-a43a-3f3451b26651",
   "metadata": {},
   "source": [
    "## Exercise 7\n",
    "Now that you know more about lists, revisit plots. Modify your plotting program like this:\n",
    "```python\n",
    "import matplotlib.pyplot as plt\n",
    "x = [1, 2, 3, 4, 5, 6, 7, 8]\n",
    "y = [1, 7, 3, 5, 12, 4.5, 2, 10]\n",
    "plt.plot(x, y)\n",
    "plt.show()\n",
    "```\n",
    "1. Modify your plotting program so that it will make a plot only of X[2:6] and Y[2:6].\n",
    "2. Modify your plotting program so that it will make a plot only of X[2:6] and Y[3:7].\n",
    "3. Modify your plotting program so that it will make a plot only of X[2:6] and Y[3:8]. Why doesn't this work?\n",
    "\n",
    "Hint: check how many values of x there are, then compute how many values of y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ee34b04-1615-4af9-9ce6-8a93663cd62e",
   "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}