Collections_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Primer\n",
    "* Python is a general purpose programming language, popular for its ease of use and wide range of libraries.\n",
    "* Major use cases:\n",
    "    * Scripting: Read/write files, control submission of jobs\n",
    "    * Prototyping: Can quickly test \n",
    "    * High level interface"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting Started\n",
    "\n",
    "* Anaconda:\n",
    "    * Free distribution of Python, available on cluster\n",
    "    * Variety of useful packages:\n",
    "        * Numpy (math with arrays)\n",
    "        * Scipy (advanced linear algebra/calculus/optimization functions)\n",
    "        * Sympy (symbolic math operations)\n",
    "        * Pandas (dataframes for organizing various data types)\n",
    "        * Matplotlib (plotting)\n",
    "* Pycharm:\n",
    "    * Free Python GUI, useful editor functions (syntax highlighting, smart refactoring, debugger)\n",
    "    * Git integration\n",
    "* Juptyer Notebook:\n",
    "    * Online environment combining formatted text and code\n",
    "    * Good for making tutorials, lab reports, documentation\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics\n",
    "\n",
    "* Python is dynamically typed, don't need to manually allocate memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "x=\"apple\" #Need to do `str x=3` in static language\n",
    "print(x)\n",
    "x=3 #Can change the type of a variable, would give error in other languages\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* If a particular type is needed, can easily convert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n",
      "3\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(float(x))\n",
    "print(str(x))\n",
    "print(bool(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The type of a variable can affect how it behaves when operated on"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5\n",
      "1\n",
      "6\n",
      "dogdog\n"
     ]
    }
   ],
   "source": [
    "print(x/2) #integer division converts to float (in Python3.x)\n",
    "print(x//2) #truncates and remains int\n",
    "\n",
    "print(2*x) \n",
    "print(2*\"dog\") #string multiplication repeats the string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Structures in Python\n",
    "* Hugely important for writing clear and efficient code\n",
    "* Key examples\n",
    "    * Lists [var,...]\n",
    "    * Dicts {name : var,...}\n",
    "    * Sets {var,...}\n",
    "    * Tuples tuple(var,...)\n",
    "    * Arrays numpy.array(var,...) (requires numpy)\n",
    "\n",
    "### Creating Lists Pythonically\n",
    "* Take the even numbers from an existing list and square them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "standard way\n",
      "[100, 4, 4]\n",
      "Python way\n",
      "[100, 4, 4]\n"
     ]
    }
   ],
   "source": [
    "B=[10,2,3,7,5,2,1]\n",
    "print(\"standard way\")\n",
    "C=[]\n",
    "for i in range(len(B)):\n",
    "    if B[i]%2==0:  #Comparison, returns true if equal\n",
    "        C.append(B[i]**2)\n",
    "print(C)\n",
    "        \n",
    "print(\"Python way\")\n",
    "C=[b**2 for b in B if b%2==0] #list comprehension\n",
    "print(C)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Create the multiplication table from 0 to 4 (using a list of lists)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "standard way\n",
      "[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8], [0, 3, 6, 9, 12], [0, 4, 8, 12, 16]]\n",
      "Python way\n",
      "[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8], [0, 3, 6, 9, 12], [0, 4, 8, 12, 16]]\n"
     ]
    }
   ],
   "source": [
    "print(\"standard way\")\n",
    "A=[]\n",
    "for i in range(5): #iterate from 0 to 4\n",
    "    temp=[]\n",
    "    for j in range(5):\n",
    "        temp.append(i*j)\n",
    "    A.append(temp)    \n",
    "print(A)\n",
    "\n",
    "print(\"Python way\")\n",
    "table=[[i*j for j in range(5)] for i in range(5)] #nested list comprehension\n",
    "print(table)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Lists Pythonically\n",
    "* Different parts of a list can be accessed conveniently by *indexing* and *slicing*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "0\n",
      "9\n",
      "[3, 4, 5]\n",
      "[2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 2, 4, 6, 8] [1, 3, 5, 7, 9]\n",
      "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n",
      "\n",
      "8\n",
      "[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "A=[i for i in range(10)]\n",
    "print(A)\n",
    "print(A[0]) #First element\n",
    "print(A[-1]) #Last element\n",
    "print(A[3:6]) #Slice containing A[3],A[4],A[5]\n",
    "print(A[2:]) #Slice from A[2] through last element\n",
    "print(A[::2],A[1::2]) #Even and odd indices\n",
    "print(A[::-1]) #Reversed list\n",
    "\n",
    "print()\n",
    "#Similar for multidimensional lists, basically lists of lists\n",
    "print(table[-1][2]) #Column 2 of last row (element 2 of last list)\n",
    "print(table[:][1]) #Every element of column 1 (element 1 of each sublist)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Convenient builtins for modifying and searching within list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 1, 4, 5, 6, 7, 8, 9]\n",
      "[0, 100, 1, 4, 5, 6, 7, 8, 9]\n",
      "[0, 100, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "B=A[:] #deep copy of list\n",
    "B.remove(2) #If found, remove one occurrence of this value\n",
    "print(B)\n",
    "print(A) #Doesn't change original list, B=A would have\n",
    "\n",
    "del B[2] #Delete second element from list\n",
    "print(B)\n",
    "\n",
    "B.insert(1,100) #Place value at specific position\n",
    "print(B)\n",
    "\n",
    "C=B[:2]+A[2:] #Create new combined list\n",
    "print(C)\n",
    "\n",
    "print(1 in C) #Checks if value in list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Can pack/unpack elements from a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "[2, 3]\n",
      "[1, 3, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "A=[1,2,3,4]\n",
    "a,b,c,d=A #assign each element to a variable\n",
    "print(c)\n",
    "\n",
    "a,*b,c=A #packs everything but first and last into b\n",
    "print(b)\n",
    "\n",
    "A[1],A[2]=A[2],A[1] #quickly swap elements in list\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Text Processing with lists\n",
    "* Can read in a file as a string for each line\n",
    "* Builtins to break up the lines into a list of individual strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Linus', 'Pauling', '(February', '28,', '1901-', 'August', '19,', '1994)*,', 'the', 'only', 'person', 'who', 'has', 'won', 'two', 'undivided', 'Nobel', 'Prizes,']\n",
      "Pauling occurrences= [1]\n",
      "Linus Pauling (February 28, 1901- August 19, 1994)*, *** only person who has won two undivided Nobel Prizes,\n",
      "\n",
      "['was', 'born', 'in', 'Portland,', 'Oregon,', 'the', 'son', 'of', 'a', 'pharmacist,', 'Henry', 'H.W.', 'Pauling,', 'and', 'Lucy', '(Darling)', 'Pauling.']\n",
      "Pauling occurrences= [12, 16]\n",
      "was born in Portland, Oregon, *** son of a pharmacist, Henry H.W. Pauling, and Lucy (Darling) Pauling.\n",
      "\n",
      "['He', 'attended', 'Washington', 'High', 'School', 'in', 'Portland', 'but', 'because', 'of', 'a', 'technicality', 'did', 'not', 'receive', 'his', 'diploma', 'until', '1962,']\n",
      "Pauling occurrences= []\n",
      "He attended Washington High School in Portland but because of a technicality did not receive his diploma until 1962,\n",
      "\n",
      "['long', 'after', 'he', 'had', 'received', 'his', 'bachelor’s', 'degree', 'from', 'Oregon', 'State', 'College', 'in', '1922,', 'his', 'doctorate', 'from', 'the']\n",
      "Pauling occurrences= []\n",
      "long after he had received his bachelor’s degree from Oregon State College in 1922, his doctorate from ***\n",
      "\n",
      "['California', 'Institute', 'of', 'Technology', 'in', '1925,', 'and', 'honorary', 'degrees', 'from', 'universities', 'in', 'seven', 'countries.']\n",
      "Pauling occurrences= []\n",
      "California Institute of Technology in 1925, and honorary degrees from universities in seven countries.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#with is a context manager: do the following with e.g. a file open, different print precision, etc\n",
    "with open(\"bio.txt\", 'r') as fil: #'r' option to read, 'w' to write\n",
    "    for line in fil: \n",
    "        rep=line.replace(\"the\",\"***\") #Replaces first with second in a string\n",
    "        sp=line.split() #Breaks string into list of strings based on whitespace \n",
    "        occ=[i for i in range(len(sp)) if \"Pauling\" in sp[i]] #List of indices where a particular string occurs\n",
    "        print(sp)\n",
    "        print(f\"Pauling occurrences= {occ}\") #f-strings allow you to run code in {} and convert to string\n",
    "        print(rep)            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Other builtin collections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List are probably the best general starting point, but there are better collections to work with for specialized cases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Similar to list, but fixed length and fixed values\n",
    "    * Can access indices/slices and unpack values, but can't change/remove/add values\n",
    "* Useful for storing related values that you won't change during runtime\n",
    "    * Not required to be the same type\n",
    "* Functions returning multiple variables return them as a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "('Origin', 1.0, 7)\n",
      "('Coordinate Axes', [1, 2, 3], [0, 1, 0], [0, 0, 1])\n"
     ]
    }
   ],
   "source": [
    "T=(1,2,3)\n",
    "a,b,c=T\n",
    "print(b)\n",
    "#T[1]=4 #Should give TypeError\n",
    "\n",
    "O=(\"Origin\",1.00,7)\n",
    "print(O)\n",
    "\n",
    "C=(\"Coordinate Axes\",[1,0,0],[0,1,0],[0,0,1]) #Can store multable variables\n",
    "#C[1]=14 #Will give TypeError\n",
    "C[1][:]=[1,2,3] #Changing contents of the variable, not the variable itself\n",
    "print(C)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Mathematical sets, can change in size, but only saves unique, immutable elements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S1={0, 1, 2, 3, 4}\n",
      "S2={0, 2, 4, 6, 8}\n",
      "{0, 1, 2, 3, 4, 5, 6, 8}\n",
      "{1, 3, 5, 6, 8}\n",
      "{0, 2, 4}\n",
      "{1, 3, 5}\n",
      "False\n",
      "{0, 2, 4, 6, 8, (1, 2, 3)}\n",
      "Unique elements=8\n"
     ]
    }
   ],
   "source": [
    "S1={i for i in range(5)}\n",
    "S2={i for i in range(0,10,2)}\n",
    "print(\"S1=\"+str(S1))\n",
    "print(\"S2=\"+str(S2))\n",
    "\n",
    "S1.add(5) #Add an element\n",
    "print(S1|S2) #Union/or\n",
    "print(S1^S2) #Exclusive or\n",
    "print(S1&S2) #Intersection/and\n",
    "print(S1-S2) #Set difference (remove elements of 2nd set from 1st)\n",
    "print(S1>=S2) #Is S1 a superset of S2?\n",
    "\n",
    "#S2.add([1,2,3]) #Type error, lists are mutable\n",
    "S2.add((1,2,3)) #Tuples are immutable, works\n",
    "print(S2)\n",
    "\n",
    "L1=[2,2,2,3,7,5,4,3,8,9,4,5,5,7,10]\n",
    "print(f\"Unique L1 elements={len(set(L1))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Like a list, but stores both keys and values. Keys are immutable, values can be mutable. \n",
    "* Since Python 3.7, stored in the order added. Earlier versions didn't maintain order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'first': 1, 'second': 2, 'third': 3}\n",
      "{'apple': 3.0, 'orange': 2.5, 'banana': 4.25}\n"
     ]
    }
   ],
   "source": [
    "A={\"first\":1,\"second\":2,\"third\":3}\n",
    "print(A)\n",
    "\n",
    "fruits=[\"apple\",\"orange\",\"banana\"]\n",
    "prices=[3.00,2.50,4.25]\n",
    "groceries={k:v for k,v in zip(fruits,prices)} #dict comprehension\n",
    "print(groceries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Differences compared to list due to the need to access keys/values together or separately"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'orange', 'banana']\n",
      "[3.0, 2.5, 4.25]\n",
      "0\n",
      "{'apple': 3.0, 'orange': 2.5, 'banana': 4.25, 'grape': 0.25}\n",
      "{'first': 1, 'second': 2, 'third': 3, 'apple': 3.0, 'orange': 2.5, 'banana': 4.25, 'grape': 0.25}\n"
     ]
    }
   ],
   "source": [
    "print(list(groceries.keys()))\n",
    "print(list(groceries.values()))\n",
    "\n",
    "#print(groceries[\"grape\"]) #Gives KeyError\n",
    "print(groceries.get(\"grape\",0)) #Returns value if present or default if not\n",
    "groceries[\"grape\"]=.25\n",
    "groceries.setdefault(\"grape\",1400) #Adds only if not already present\n",
    "print(groceries)\n",
    "\n",
    "big={**A,**groceries} #Unpack to combine two dicts\n",
    "print(big)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Write a csv file with various data categories\n",
    "  * Also possible with builtin csv library, but more steps "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd #Anaconda library\n",
    "data=pd.DataFrame({\"Label\":(\"Dogs\",\"Cats\",\"Monkeys\"),\n",
    "                  \"Amount\":(20,10,2),\n",
    "                  \"Price\":(50.0,75.0,1e3)})         #Line continuation until end of parenthesis\n",
    " \n",
    "data.to_csv(\"data.csv\",index=False) #index adds a column of row numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy arrays\n",
    "* Fixed size, variable elements. Designed for ease of performing mathematical operations\n",
    "* Not builtin to Python, must be downloaded separately or included with Anaconda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making arrays\n",
    "* A few different methods, depending on how simple a structure you are working with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "[1 7 9]\n",
      "\n",
      "B\n",
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
      " 24]\n",
      "(25,)\n",
      "[[ 0  5 10 15 20]\n",
      " [ 1  6 11 16 21]\n",
      " [ 2  7 12 17 22]\n",
      " [ 3  8 13 18 23]\n",
      " [ 4  9 14 19 24]]\n",
      "(5, 5)\n",
      "\n",
      "C\n",
      "[ 0 13  4 13 16 13 36 13 64 13]\n",
      "\n",
      "D\n",
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n",
      "\n",
      "E\n",
      "[[3. 0. 0.]\n",
      " [0. 3. 0.]\n",
      " [0. 0. 3.]]\n",
      "\n",
      "F\n",
      "[ 1.  1.  2.  3.  5.  8. 13. 21. 34. 55.]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "print(\"A\")\n",
    "A=np.array([1,7,9]) #By hand, usually only for small arrays with no discernible pattern\n",
    "print(A)\n",
    "\n",
    "print(\"\\nB\")\n",
    "B=np.arange(25) #Simple patterns\n",
    "print(B)\n",
    "print(B.shape)\n",
    "newB=np.reshape(B,(5,5)) #Turns into 5 by 5 array\n",
    "print(newB.T) #can also do np.transpose(newB)\n",
    "print(newB.shape)\n",
    "\n",
    "print(\"\\nC\")\n",
    "C=np.array([j**2 if j%2==0 else 13 for j in range(10)]) #More complicated patterns\n",
    "print(C)\n",
    "\n",
    "print(\"\\nD\")\n",
    "D=np.zeros((3,3)) #Array of zeros, good for when you know the shape, but little else\n",
    "print(D)\n",
    "\n",
    "print(\"\\nE\")\n",
    "E=np.eye(3) #Identity matrix\n",
    "E*=3 #Elementwise multiplication\n",
    "print(E)\n",
    "\n",
    "print(\"\\nF\")\n",
    "F=np.fromfile(\"array.txt\",sep=\" \") #large dataset, already formatted\n",
    "print(F)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Arrays\n",
    "* Most commonly just trying to line combine a large set of numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Operations by element\n",
      "[0.000000e+00 1.690000e+02 6.400000e+01 1.521000e+03 6.400000e+03\n",
      " 1.081600e+04 2.190240e+05 7.452900e+04 4.734976e+06 5.112250e+05]\n",
      "[[ 0  1  4  9 16]\n",
      " [ 0  6 14 24 36]\n",
      " [ 0 11 24 39 56]\n",
      " [ 0 16 34 54 76]\n",
      " [ 0 21 44 69 96]]\n",
      "[[ 0  0  0  0  0]\n",
      " [ 5  6  7  8  9]\n",
      " [20 22 24 26 28]\n",
      " [45 48 51 54 57]\n",
      " [80 84 88 92 96]]\n",
      "\n",
      "Matrix/vector operations\n",
      "3876.0\n",
      "[[   0.    0.    0.    0.    0.    0.    0.    0.    0.    0.]\n",
      " [  13.   13.   26.   39.   65.  104.  169.  273.  442.  715.]\n",
      " [   4.    4.    8.   12.   20.   32.   52.   84.  136.  220.]\n",
      " [  13.   13.   26.   39.   65.  104.  169.  273.  442.  715.]\n",
      " [  16.   16.   32.   48.   80.  128.  208.  336.  544.  880.]\n",
      " [  13.   13.   26.   39.   65.  104.  169.  273.  442.  715.]\n",
      " [  36.   36.   72.  108.  180.  288.  468.  756. 1224. 1980.]\n",
      " [  13.   13.   26.   39.   65.  104.  169.  273.  442.  715.]\n",
      " [  64.   64.  128.  192.  320.  512.  832. 1344. 2176. 3520.]\n",
      " [  13.   13.   26.   39.   65.  104.  169.  273.  442.  715.]]\n",
      "[[ 30]\n",
      " [ 80]\n",
      " [130]\n",
      " [180]\n",
      " [230]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Operations by element\")\n",
    "print((C * F)**2) #Multiply element by element, then square each\n",
    "v=np.arange(5)\n",
    "print(newB*v) #Broadcasting along columns\n",
    "v=v.reshape((5,1)) \n",
    "print(newB*v) #Broadcasting along rows\n",
    "\n",
    "print(\"\\nMatrix/vector operations\")\n",
    "print(np.dot(C,F)) #Dot product\n",
    "outer=np.outer(C,F)\n",
    "print(outer) #Outer product\n",
    "print(newB@v) #Matrix multiplication, np.multiply(newB,v) before Python3.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Some additional indexing/postprocessing that is unique to arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remove less than 50\n",
      "[[   0.    0.    0.    0.    0.    0.    0.    0.    0.    0.]\n",
      " [   0.    0.    0.    0.   65.  104.  169.  273.  442.  715.]\n",
      " [   0.    0.    0.    0.    0.    0.   52.   84.  136.  220.]\n",
      " [   0.    0.    0.    0.   65.  104.  169.  273.  442.  715.]\n",
      " [   0.    0.    0.    0.   80.  128.  208.  336.  544.  880.]\n",
      " [   0.    0.    0.    0.   65.  104.  169.  273.  442.  715.]\n",
      " [   0.    0.   72.  108.  180.  288.  468.  756. 1224. 1980.]\n",
      " [   0.    0.    0.    0.   65.  104.  169.  273.  442.  715.]\n",
      " [  64.   64.  128.  192.  320.  512.  832. 1344. 2176. 3520.]\n",
      " [   0.    0.    0.    0.   65.  104.  169.  273.  442.  715.]]\n",
      "Keep lower triangle\n",
      "[   0.   13.   13.    4.    4.    8.   13.   13.   26.   39.   16.   16.\n",
      "   32.   48.   80.   13.   13.   26.   39.   65.  104.   36.   36.   72.\n",
      "  108.  180.  288.  468.   13.   13.   26.   39.   65.  104.  169.  273.\n",
      "   64.   64.  128.  192.  320.  512.  832. 1344. 2176.   13.   13.   26.\n",
      "   39.   65.  104.  169.  273.  442.  715.]\n",
      "[[   0.    0.    0.    0.    0.    0.    0.    0.    0.    0.]\n",
      " [  13.   13.    0.    0.    0.    0.    0.    0.    0.    0.]\n",
      " [   4.    4.    8.    0.    0.    0.    0.    0.    0.    0.]\n",
      " [  13.   13.   26.   39.    0.    0.    0.    0.    0.    0.]\n",
      " [  16.   16.   32.   48.   80.    0.    0.    0.    0.    0.]\n",
      " [  13.   13.   26.   39.   65.  104.    0.    0.    0.    0.]\n",
      " [  36.   36.   72.  108.  180.  288.  468.    0.    0.    0.]\n",
      " [  13.   13.   26.   39.   65.  104.  169.  273.    0.    0.]\n",
      " [  64.   64.  128.  192.  320.  512.  832. 1344. 2176.    0.]\n",
      " [  13.   13.   26.   39.   65.  104.  169.  273.  442.  715.]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Remove less than 50\")\n",
    "newOut=np.copy(outer)\n",
    "newOut[np.abs(newOut)<50]=0 #Index by a boolean condition\n",
    "print(newOut)\n",
    "\n",
    "print(\"Keep lower triangle\")\n",
    "mask=np.tri(10,dtype=bool) #Matrix of True in lower triangle, False in upper\n",
    "print(outer[mask]) #Extract lower triangle into 1D array\n",
    "outer*=mask #All indices where mask is False to zero \n",
    "print(outer)"
   ]
  },
  {
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}