objects.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sequences\n",
    "* Access using bracket notation, either left-to-right (positive index, eg. S[2]) or right-to-left (negative index, eg. S[-3])\n",
    "* Support slicing (eg. S[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "* Mutable sequences of objects of any time\n",
    "* Used to store homogenous items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lists\n",
    "numbers = [2,4,6,8]\n",
    "numbers[0] # => 2\n",
    "numbers[-1] # => 8\n",
    "numbers.append(10) # mutable, can modify content\n",
    "x = [12, 14, 16]\n",
    "numbers + x # concatenating lists\n",
    "type(_) # => returns most recent object type\n",
    "numbers.reverse() # => list methods work in place\n",
    "numbers # => numbers are now reversed\n",
    "names = ['Dan', 'Joe', 'Jimmy', 'Zany']\n",
    "names.sort()\n",
    "names # => names are now sorted alphabetically\n",
    "names.reverse() # => reverse order\n",
    "sorted_names = sorted(names) # => sorted creates a new sorted list\n",
    "len(names) # => returns length of names object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "* immutable sequences used to store heterogenous data\n",
    "* many uses\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 0)\n",
      "(1, 1)\n",
      "(2, 4)\n",
      "(4, 6)\n",
      "(8, 10)\n",
      "(12, 15)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tuples\n",
    "T = (1,3,5,7) # => create using parenthesis\n",
    "len(T) # => len works the same as lists\n",
    "T + (9, 11) # => concatenation works the same too\n",
    "T[1] # => indices work the same too\n",
    "x = 12.23\n",
    "y = 23.34\n",
    "coordinate = (x,y) # => tuple packing\n",
    "type(coordinate) # => tuple\n",
    "c1, c2 = coordinate # => unpacking a tuple\n",
    "coordinates = [(0,0),(1,1),(2,4),(4,6),(8,10),(12,15)] \n",
    "for (x,y) in coordinates: # can use tuples in for loops\n",
    "    print(x,y)\n",
    "c = (2,3)\n",
    "type(c) # => tuple\n",
    "c = (2)\n",
    "type(c) # => int\n",
    "c = ((2,)) # => create a tuple with a single object\n",
    "type(c) # => tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ranges\n",
    "* immutable sequences of integeres\n",
    "* commonly used on for loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9, 11]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ranges\n",
    "list(range(5)) # converts range into a list => [0, 1, 2, 3, 4]\n",
    "list(range(1,6)) # starts at 1 and ends at 5\n",
    "list(range(1,12,2)) # increments by 2\n",
    "# don't turn range objects into lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "* immutable sequences of characters\n",
    "* enclose with single, double or triple quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function lower>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Strings\n",
    "S = \"Python\"\n",
    "len(S) # => 6\n",
    "\"y\" in S # => returns True\n",
    "\"hello \" + \"world\" # => \"hello world\" (concatenation)\n",
    "3 * S # => \"PythonPythonPython\"\n",
    "dir(str) # => list of string attributes\n",
    "# str.replace? # => returns documentation for this method\n",
    "name = \"Tina Fey\"\n",
    "name.replace(\"T\", \"t\") # => tina Fey\n",
    "names = name.split(' ')\n",
    "type(names[0])\n",
    "names[0].upper()\n",
    "names[1].lower"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n",
    "* unordered collection of distinct hashable objects\n",
    "* two types: set (mutable) and frozen set (immutable)\n",
    "* cannot be indexed\n",
    "* elements cannot be duplicated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sets\n",
    "ids = set() # => creates empty set\n",
    "ids = set([0,1,2,3,4,5,6,7,8,9])\n",
    "len(ids) # => returns length of set\n",
    "ids.add(10) # => adds 10 to set\n",
    "ids.add(2) # => nothing happens\n",
    "ids.pop() # => removes arbitrary element\n",
    "males = set([1,2,3,4,5])\n",
    "females = ids - males # => assigns females to all of items except males\n",
    "everyone = males | females # => union of males and females\n",
    "everyone & set([1,2,3]) # => intersection \n",
    "word = \"antidisestablishmentarianism\"\n",
    "letters = set(word)\n",
    "len(letters) # => returns unique letters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "* mappings of key objects to value objects\n",
    "* keys must be immutable, values are mutable\n",
    "* dictionaries are mutable\n",
    "* quick lookups for unordered data (do not maintain order)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dictionaries\n",
    "age = {} # => empty dictionary\n",
    "age = dict() # => empty dictionary\n",
    "age = {\"Tim\": 29, \"Jeff\": 30, \"Jim\" :18}\n",
    "age['Tim'] # => returns 29\n",
    "age['Tim'] += 1\n",
    "age.keys # => returns a view object with keys\n",
    "names = age.keys \n",
    "type(names) # => dict_keys\n",
    "age.values # => returns a view object with values\n",
    "ages = age.values()\n",
    "'Tim' in age # => True \n",
    "'Sophia' in age # => False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For and While Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "Jim\n",
      "Jon\n",
      "Jill\n",
      "Jeff\n",
      "Jax\n",
      "('Jill', 44)\n",
      "('Jim', 88)\n",
      "('Jax', 11)\n",
      "('Jon', 66)\n",
      "('Jeff', 22)\n",
      "('Jon', 66)\n",
      "('Jim', 88)\n",
      "('Jill', 44)\n",
      "('Jeff', 22)\n",
      "('Jax', 11)\n"
     ]
    }
   ],
   "source": [
    "# For Loops - use when you know how many iterations\n",
    "for x in range(10):\n",
    "    print(x)\n",
    "names = ['Jim', 'Jon', 'Jill', 'Jeff', 'Jax']\n",
    "for name in names:\n",
    "    print(name)\n",
    "age = {'Jim' : 88, 'Jon': 66, 'Jill' : 44, 'Jeff' : 22, 'Jax' : 11}\n",
    "for name in age.keys():\n",
    "    print(name, age[name])\n",
    "    \n",
    "for name in sorted(age.keys(), reverse=True): # sort reverse alphabetically\n",
    "    print(name, age[name])\n",
    "\n",
    "# Use a while loop to test a condition an unknown number of times\n",
    "while "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehensions\n",
    "* operator that allows you to iterate over a list\n",
    "* very fast and elegant/concise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = range(10)\n",
    "squares = [number**2 for number in numbers]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading and Writing Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "touch input.txt && echo \"Lorem \\nipsum \\ndolor \\nsit \\namet, \\nconsectetur \\nadipiscingd\" > input.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lorem \\nipsum \\ndolor \\nsit \\namet, \\nconsectetur \\nadipiscingd\n",
      "\n",
      "['Lorem', '\\\\nipsum', '\\\\ndolor', '\\\\nsit', '\\\\namet,', '\\\\nconsectetur', '\\\\nadipiscingd']\n"
     ]
    }
   ],
   "source": [
    "filename = \"input.txt\"\n",
    "for line in open(filename):\n",
    "    print(line)\n",
    "    \n",
    "for line in open(filename):\n",
    "    line = line.rstrip().split(' ')\n",
    "    print(line)\n",
    "    \n",
    "F = open('output.txt', 'w')\n",
    "F.write(\"Python\\n\")\n",
    "F.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "* devices for grouping statements for reuse and to minimize redundancy\n",
    "* Enable dividing large tasks into smaller chunks(procedural decomposition)\n",
    "* To modify global variables from within a function, use the Global statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'xuzj8uy84es8kk8y8jn6x0ax1hxs0bo16rbu5nfoo14tjulznp04lgl73412gyjxmb0kxt2n2u7mjbcfsx7ivv28k3qnyucntrl5'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "def add(a,b):\n",
    "    mysum = a + b\n",
    "    return mysum\n",
    "\n",
    "def add_and_subtract(a,b):\n",
    "    mysum = a + b\n",
    "    mydiff = a - b\n",
    "    return (mysum, mydiff)\n",
    "\n",
    "newadd = add # can reassign functions\n",
    "\n",
    "def modify(my_list):\n",
    "    my_list[0] *= 10\n",
    "\n",
    "def intercect(s1,s2):\n",
    "    res = []\n",
    "    for x in s1:\n",
    "        if x in s2:\n",
    "            res.append(x)\n",
    "    return res\n",
    "\n",
    "def password(length):\n",
    "    pw = str()\n",
    "    characters = 'abcdefghijklmnopqrstuvwxyz' + '0123456789'\n",
    "    for i in range(length):\n",
    "        pw += random.choice(characters)\n",
    "    return pw\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}