{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Importing Modules" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Lines like this, beginning with '#', are comments that are ignored\n", "# by Python. It's a good idea to comment your code to make it clear\n", "# what's going on\n", "\n", "# Import the numpy module to provide numerical functionality\n", "import numpy as np\n", "\n", "# Import the matplotlib.pyplot module to provide plotting functionality\n", "import matplotlib.pyplot as plt\n", "\n", "# Tell matplotlib.pyplot to do inline plots\n", "%matplotlib inline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Variables" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n", "\n", "5.0\n", "\n" ] } ], "source": [ "# Create an integer variable\n", "\n", "x = 5\n", "\n", "# Print it out and then print its type. print() is a built-in\n", "# Python functions that prints out a value; type() is another\n", "# built-in function that returns the type of a variable\n", "\n", "print(x)\n", "print(type(x))\n", "\n", "# Create a float variable (for representing real numbers). Note the\n", "# decimal point!\n", "\n", "x = 5.\n", "\n", "print(x)\n", "print(type(x))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Numerical Operations" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n", "5.0\n", "5.0\n", "5.0\n" ] } ], "source": [ "# Addition with integers and floats (math on mixed types will\n", "# convert integers to float)\n", "\n", "myInteger = 2\n", "myFloat = 2.\n", "\n", "print(myInteger + 3)\n", "print(myInteger + 3.)\n", "\n", "print(myFloat + 3)\n", "print(myFloat + 3.)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "12\n", "0.3333333333333333\n", "0\n", "12.0\n", "0.3333333333333333\n" ] } ], "source": [ "# Multiplication and division with integers and floats\n", "\n", "print(myInteger*6)\n", "print(myInteger/6) # Converts myInteger to float\n", "print(myInteger//6) # Doesn't convert myInteger to float\n", "\n", "print(myFloat*6)\n", "print(myFloat/6)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4.0\n", "7.38905609893065\n", "0.6931471805599453\n", "0.3010299956639812\n", "0.9092974268256817\n", "1.4142135623730951\n", "nan\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Users/townsend/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:11: RuntimeWarning: invalid value encountered in sqrt\n", " # This is added back by InteractiveShellApp.init_path()\n" ] } ], "source": [ "# Some other math operators and functions\n", "\n", "print(myFloat**2) # The ** operator raises to a power\n", "\n", "print(np.exp(myFloat)) # Exponentiation (provided by numpy module)\n", "print(np.log(myFloat)) # Natural logarithm (provided by numpy module)\n", "print(np.log10(myFloat)) # Base-10 logarithm (provided by numpy module)\n", "print(np.sin(myFloat)) # Sine (provided by numpy module)\n", "\n", "print(np.sqrt(myFloat)) # Square root (provided by numpy module)\n", "print(np.sqrt(-myFloat)) # This should produce a 'nan' (Not-a-Number)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(-1+2j)\n", "\n", "(0.7861513777574233+1.272019649514069j)\n" ] } ], "source": [ "# Create a complex variable\n", "\n", "myComplex = complex(-1.,2.) # The complex() function returns a complex number\n", "myComplex = -1. + 2.*1j # Same effect as previous command\n", "\n", "print(myComplex)\n", "print(type(myComplex))\n", "\n", "print(np.sqrt(myComplex)) # The sqrt() function works as it should with complex numbers\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Strings" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "This is my string\n", "\n", "17\n" ] } ], "source": [ "# Create a string\n", "\n", "myString = 'This is my string' # Note quotes ''\n", "\n", "print(myString)\n", "print(type(myString))\n", "\n", "print(len(myString)) # The len() function returns the length of a string\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "T\n", "h\n", "g\n", "g\n", "n\n" ] } ], "source": [ "# String indexing\n", "\n", "print(myString[0]) # Print the first character (index 0)\n", "print(myString[1]) # Print the second character (index 1)\n", "\n", "L = len(myString)\n", "\n", "print(myString[L-1]) # Print the last character\n", "print(myString[-1]) # Easier way to print the last character\n", "print(myString[-2]) # Print the second-to-last character" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "is my\n", "This is my\n", "is my string\n", "This is my string\n" ] } ], "source": [ "# String slicing\n", "\n", "print(myString[5:10]) # Print characters with indices from 5 (inclusive) to 10 (exclusive)\n", "print(myString[:10]) # Print charcters from the start to index 10 (exclusive)\n", "print(myString[5:]) # Print characters from index 5 (inclusive) to the end\n", "print(myString[:]) # Print all characters" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "My lucky number is 7\n" ] } ], "source": [ "# String concatenation\n", "\n", "num = 7\n", "numString = str(num) # The str() function converts a number to a string\n", "\n", "anotherString = 'My lucky number is ' + numString\n", "print(anotherString)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Lists & Tuples" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['eggs', 'potatoes', 42, 180.0, 'bucky']\n", "\n", "5\n" ] } ], "source": [ "# Create a list\n", "\n", "myList = ['eggs', 'potatoes', 42, 180., 'bucky'] # Note square brackets []\n", "\n", "print(myList)\n", "print(type(myList))\n", "print(len(myList)) # The len() function returns the length of a list" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "potatoes\n", "180.0\n", "['potatoes', 42]\n", "['eggs', 'potatoes', 42]\n", "[180.0, 'bucky']\n", "['eggs', 'potatoes', 42, 180.0, 'bucky', (1+3j), 'eureka!']\n" ] } ], "source": [ "# List indexing, slicing and concatenation\n", "\n", "print(myList[1])\n", "print(myList[-2])\n", "\n", "print(myList[1:3])\n", "print(myList[:3])\n", "print(myList[3:])\n", "\n", "anotherList = myList + [1+3*1j, 'eureka!']\n", "\n", "print(anotherList)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['Ostrich eggs', 'potatoes', 42, 180.0, -1, -2, 'eureka!']\n" ] } ], "source": [ "# Modify a list using indexing and slicing\n", "\n", "anotherList[0] = 'Ostrich eggs'\n", "anotherList[4:6] = [-1, -2]\n", "\n", "print(anotherList)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(0, 1, 2.0, 3.0, 'four', 'five')\n", "\n" ] }, { "ename": "TypeError", "evalue": "'tuple' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmyTuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mmyTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Nought'\u001b[0m \u001b[0;31m# Will cause an error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" ] } ], "source": [ "# Create a tuple\n", "\n", "myTuple = (0, 1, 2., 3., 'four', 'five') # Note parentheses ()\n", "\n", "print(myTuple)\n", "print(type(myTuple))\n", "\n", "myTuple[0] = 'Nought' # Will cause an error" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Arrays" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0 1 2 3 4 5]\n", "\n", "\n", "(6,)\n" ] } ], "source": [ "# Create an array\n", "\n", "myArray = np.array([0, 1, 2, 3, 4, 5]) # The np.array() function creates an array from a list\n", "\n", "print(myArray)\n", "print(type(myArray))\n", "print(type(myArray[0]))\n", "print(myArray.shape) # The .shape operator returns the dimensions of an array" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 0 2 4 6 8 10]\n", "[ 0 2 4 6 8 10]\n", "[ 1. 2.71828183 7.3890561 20.08553692 54.59815003\n", " 148.4131591 ]\n" ] } ], "source": [ "# Array arithmetic\n", "\n", "print(myArray*2)\n", "print(myArray + myArray)\n", "print(np.exp(myArray))" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0. 1.5 3. 4.5]\n", "[10. 12.5 15. 17.5 20. ]\n" ] } ], "source": [ "# Alternative ways to create arrays\n", "\n", "anotherArray = np.arange(0., 6., 1.5) # From 0 (inclusive) to 6 (exclusive) in steps of 1.5\n", "print(anotherArray)\n", "\n", "anotherArray = np.linspace(10., 20., 5) # From 10 to 20 (inclusive) with 5 values\n", "print(anotherArray)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Dicts" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'width': 8.5, 'height': 11, 'shape': 'rectangle'}\n", "\n", "dict_keys(['width', 'height', 'shape'])\n", "dict_values([8.5, 11, 'rectangle'])\n" ] } ], "source": [ "# Define a dict using a sequence of key-value pairs\n", "\n", "myDict = {'width': 8.5, 'height': 11, 'shape':'rectangle'} # Note braces {}\n", "\n", "print(myDict)\n", "print(type(myDict))\n", "\n", "# Print out keys and values (note that ordering is arbitrary)\n", "\n", "print(myDict.keys())\n", "print(myDict.values())" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "8.5\n", "rectangle\n" ] } ], "source": [ "# Dict indexing\n", "\n", "print(myDict['width'])\n", "print(myDict['shape'])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Loops" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "eggs\n", "potatoes\n", "42\n", "180.0\n", "bucky\n", "0 eggs\n", "1 potatoes\n", "2 42\n", "3 180.0\n", "4 bucky\n", "width 8.5\n", "height 11\n", "shape rectangle\n" ] } ], "source": [ "# Iterate through the elements of a list\n", "\n", "for item in myList: # This sets the variable 'item' to each of the elements in turn\n", " print(item)\n", "\n", "# Do the same using indexing\n", "\n", "for i in range(len(myList)): # The range() function returns a list of indices\n", " print(i, myList[i])\n", "\n", "# Iterate through the elements of a dict\n", "\n", "for key, value in myDict.items():\n", " print(key, value)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Plots" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# Create plot data\n", "\n", "x = np.linspace(0., 2.*np.pi, 25) # 0 to 2pi in 25 steps\n", "\n", "y = np.sin(x)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Create a new figure\n", "\n", "plt.figure()\n", "\n", "# Plot y versus x\n", "\n", "plt.plot(x, y, color='b', label='line') # Line plot\n", "plt.scatter(x, y, color='r', label='scatter') # Scatter plot\n", "\n", "# Add axis labels and annotation\n", "\n", "plt.xlabel('x')\n", "plt.ylabel('sin(x)')\n", "\n", "plt.legend()" ] }, { "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.3" } }, "nbformat": 4, "nbformat_minor": 2 }