notebooks/Intro to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comments!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using a hash symbol before a line of text makes it a comment\n",
    "# Use a hash symbol for each line\n",
    "# The interpreter will ignore any comments, so you can\n",
    "# use comments to \"deactivate\" code when trouble shooting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "Python doesn't use special variable types to store anything, so you can assign and reassign any type to a variable, either to operate on or refer to later. Certain variable names are \"reserved\" as they are used by Python for other aspects of the language. This includes `is`, `Dict`, `True`, `if` and many more. More [here](https://www.programiz.com/python-programming/keywords-identifier)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "71\n",
      "72\n"
     ]
    }
   ],
   "source": [
    "# Surrounding a varible with single quotes makes it a string\n",
    "myString = 'Hello World'\n",
    "\n",
    "# Storing an integer\n",
    "myFavoriteNumber = 71\n",
    "\n",
    "# Boolean (true/false) are True or False (must be capitalized)\n",
    "isParsonsClass = True\n",
    "\n",
    "# We can also use variables to store references to objects\n",
    "# such as dictionaries, lists, or classes\n",
    "myList = [1, 4, 'test', 'foo']\n",
    "\n",
    "# We can use the print() function to see the output of any\n",
    "# variable after it has been operated on or assigned\n",
    "\n",
    "print(myFavoriteNumber)\n",
    "myFavoriteNumber = myFavoriteNumber + 1\n",
    "print(myFavoriteNumber)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "Lists are a convenient way to store information in a sequential format and are the most basic data containers in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "# Here we define a basic list\n",
    "\n",
    "myList = [1, 3, 55, 6, -10, 12]\n",
    "\n",
    "# To access an element in the list, we use square brackets.\n",
    "# Lists are \"0-indexed\", meaning the first element is the \n",
    "# \"zeroth\" element\n",
    "\n",
    "print(myList[0]) # this will return 1\n",
    "print(myList[2]) # this should return 55"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List operations\n",
    "\n",
    "There are many ways to operate on lists, but we'll review just a few of the essentials here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[55, 6]\n"
     ]
    }
   ],
   "source": [
    "# Slicing a list - we can grab a small subset of a list\n",
    "# using the syntax shown below\n",
    "\n",
    "mySubset = myList[2:4]\n",
    "print(mySubset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "# Getting the length of a list - the number of elements\n",
    "# in the list\n",
    "\n",
    "myListLength = len(myList)\n",
    "print(myListLength)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 55, 6, -10, 12, -5]\n"
     ]
    }
   ],
   "source": [
    "# Appending an element to the end of the list\n",
    "\n",
    "myList.append(-5)\n",
    "print(myList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This\n"
     ]
    }
   ],
   "source": [
    "# Strings can also be treated like lists with\n",
    "# each character treated like an array element\n",
    "\n",
    "myString = 'This is a very long string'\n",
    "print(myString[0:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "Dictionaries are a common way of storing key-value pair information. Dictionaries are great for any time you want to associate a value with a specific key. You can then look up the specific key for the stored value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Designing for ML\n",
      "yes, the key students is in myDict\n"
     ]
    }
   ],
   "source": [
    "myDict = { 'className': 'Designing for ML', 'students': 25, 'isCool': True }\n",
    "print(myDict['className'])\n",
    "if 'students' in myDict:\n",
    "    print('yes, the key students is in myDict')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "\n",
    "For loops allow us to iterate over the contents of a list or dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I like apples\n",
      "I like oranges\n",
      "I like pears\n",
      "I like apricots\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apples', 'oranges', 'pears', 'apricots']\n",
    "for fruit in fruits:\n",
    "    print('I like %s' % fruit)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also loop from, say, 10 to 19 using the `range` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "for i in range(10, 19):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If statements\n",
    "\n",
    "If statements allow us to check some logic and execute different code depending on that logic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is lunch time!\n"
     ]
    }
   ],
   "source": [
    "currentTime = 1\n",
    "\n",
    "if currentTime < 1:\n",
    "    print('It is not lunch time yet' )\n",
    "elif currentTime >= 1 and currentTime < 2:\n",
    "    print('It is lunch time!')\n",
    "else:\n",
    "    print('It is after lunch')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Functions allow us to reuse code into executable functions. These functions can then be called in other parts of our program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello class\n"
     ]
    }
   ],
   "source": [
    "def myFunction(myArgument):\n",
    "    # You can execute all your logic here\n",
    "    # and then return the value below\n",
    "    return 'Hello ' + myArgument\n",
    "\n",
    "print(myFunction('class'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries\n",
    "\n",
    "Core Python is only so useful without importing other libraries. We can import Python's standard (listed [here](https://docs.python.org/3/library/)), or we can use the Python package manager pip to install external libraries. Eventually, we can even write our own!\n",
    "\n",
    "Below we'll import the standard `random` library that ships with python, as well as the external libary `matplotlib` we installed with pip."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "# Create an empty list\n",
    "randomX = []\n",
    "randomY = []\n",
    "\n",
    "for i in range(0, 100):\n",
    "    randomX.append(random.random())\n",
    "    randomY.append(random.random())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting\n",
    "\n",
    "Now we can use `matplotlib` to plot our random scatter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Random scatter plot')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.figure(figsize=(6,6))\n",
    "plt.scatter(randomX, randomY)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('Random scatter plot')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading and writing files\n",
    "\n",
    "We can use Python to read and write all sorts of files to the disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intro to Python.ipynb \u001b[34mimages\u001b[m\u001b[m                savedfile.txt\r\n"
     ]
    }
   ],
   "source": [
    "# First let's write a file to the disk\n",
    "myString = 'My very important data that I want to save'\n",
    "\n",
    "# 'w' indicates that we are opening the file in \"write\" mode\n",
    "with open('savedfile.txt', 'w') as file:\n",
    "    file.write(myString)\n",
    "    \n",
    "# This should now be saved in the same folder as our notebook.\n",
    "# By typing \"!\" before a command, we can run a unix command (ls)\n",
    "# in our notebook. We can see the file listed below\n",
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My very important data that I want to save\n"
     ]
    }
   ],
   "source": [
    "# Now let's read in the same file\n",
    "# This time we use 'r' to open the file in \"read\" mode\n",
    "\n",
    "with open('savedfile.txt', 'r') as file:\n",
    "    data = file.read()\n",
    "    \n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listing directory contents\n",
    "\n",
    "One last useful thing we often need to do is list the contents of a directory. For example, we might have a folder of images that we want to list. There are many, many ways of doing this and it can be a bit confusing. I've copied the [Caltech 101](http://www.vision.caltech.edu/Image_Datasets/Caltech101/) dataset to the root of this notebook to use as an example but any nested folder jpgs would work just fine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First we need to import the os library\n",
    "import os\n",
    "\n",
    "\n",
    "# We can get a list of all the folders in the 'images' folder\n",
    "imagesFolders = os.listdir('images')\n",
    "\n",
    "# Let's list all the files in the kangaroo folder\n",
    "kangaroos = os.listdir('images/kangaroo')\n",
    "\n",
    "# Unfortunately listdir will give us all files\n",
    "# We don't need to list our non-image files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To recursively list files of a certain type, use glob\n",
    "import glob\n",
    "\n",
    "# We use './**/*.jpg' to say \"get all files from any\n",
    "# depth of directory\" and set recursive to 'True'\n",
    "files = glob.glob('./**/*.jpg', recursive=True)"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}