functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# USEFUL PYTHON FUNCTIONS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The zip() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('x', 1), ('y', 2), ('z', 3)]\n"
     ]
    }
   ],
   "source": [
    "# The zip() function with list() returns a list of tuples\n",
    "\n",
    "vars = ['x','y','z']\n",
    "vals = [1,2,3]\n",
    "\n",
    "print(list(zip(vars,vals)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('a', 10), ('b', 20), ('c', 30), ('d', 40)]\n"
     ]
    }
   ],
   "source": [
    "# zip iteration stops when one sequence is exhausted\n",
    "\n",
    "chars = 'abcd'              # a string is a sequence\n",
    "nums = [10,20,30,40,50]\n",
    "data = list(zip(chars,nums))   # NOTE that 50 is ignored \n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1200, 'Jan'), (900, 'Feb'), (1000, 'Mar')]\n",
      "[(900, 'Feb'), (1000, 'Mar'), (1200, 'Jan')]\n"
     ]
    }
   ],
   "source": [
    "# The list of tuples generated with zip() can be sorted\n",
    "\n",
    "mos = ['Jan','Feb','Mar']\n",
    "sales = [1200,900,1000]\n",
    "data = list(zip(sales,mos))\n",
    "print(data)\n",
    "data.sort()\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x : 1\n",
      "y : 2\n",
      "z : 3\n"
     ]
    }
   ],
   "source": [
    "# dict() with zip() can build a dictionary \n",
    "vars = ['x','y','z']\n",
    "vals = [1,2,3]\n",
    "\n",
    "my_dict = dict(zip(vars,vals))\n",
    "for k in my_dict:\n",
    "    print(k,':',my_dict[k])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "('a', 'b', 'c')\n",
      "('Guido', 'van', 'Rossum')\n"
     ]
    }
   ],
   "source": [
    "# zip with the unpacking operator * can unzip tuples into separate sequences.\n",
    "\n",
    "triads = list([(1,'a','Guido'),(2,'b','van'),(3,'c','Rossum')])\n",
    "nums,chs,guru = zip(*triads)\n",
    "print(nums)\n",
    "print(chs)\n",
    "print(guru)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('burgers', 'fries', 'pies')\n",
      "(3.99, 2.49, 1.99)\n",
      "(3, 2, 2)\n"
     ]
    }
   ],
   "source": [
    "# zip with the unpacking operator * also works with a list of lists\n",
    "\n",
    "purchases = [['burgers',3.99,3],['fries',2.49,2],['pies',1.99,2]]\n",
    "food,prices,qtys = zip(*purchases)\n",
    "\n",
    "print(food)\n",
    "print(prices)\n",
    "print(qtys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The filter() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The old man ate two "
     ]
    }
   ],
   "source": [
    "# filter(function,iterable)\n",
    "# uses its function argument to test each element of an iterable.\n",
    "# It returns an iterable of elements that \"pass\" the True test.\n",
    "\n",
    "# Example: Finding 3-letter strings in a list with filter\n",
    "\n",
    "def test(s):\n",
    "    return len(s) == 3\n",
    "\n",
    "# make a list of words\n",
    "words = \"The nice old man never ate those two lemon cupcakes\".split()\n",
    "\n",
    "threes = filter(test,words)\n",
    "for w in threes:\n",
    "    print(w, end = ' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The', 'old', 'man', 'ate', 'two']\n"
     ]
    }
   ],
   "source": [
    "# A lambda function can be used as the filter function\n",
    "\n",
    "threes = filter(lambda w : len(w) == 3, words)\n",
    "print(list(threes))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(92, 'Penny'), (83, 'Jenny'), (78, 'Benny'), (90, 'Kenny'), (95, 'Lenny'), (80, 'Denny')]\n",
      "The A students are : Penny Kenny Lenny "
     ]
    }
   ],
   "source": [
    "# make a list of test scores and names as tuples \n",
    "# use filter to get A students\n",
    "\n",
    "names = ['Penny','Jenny','Benny','Kenny','Lenny','Denny']\n",
    "scores = [92,83,78,90,95,80]\n",
    "\n",
    "results = list(zip(scores,names))   # makes the list of tuples\n",
    "print(results)\n",
    "\n",
    "def grade_a(tup):\n",
    "    if tup[0] >= 90:\n",
    "        return True\n",
    "\n",
    "a_names = filter(grade_a,results)\n",
    "print('The A students are :', end = ' ')\n",
    "for n in a_names:\n",
    "    print(n[1], end = ' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The map() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[25, 64, 6.25, 36, 16, 12.25]\n"
     ]
    }
   ],
   "source": [
    "# map() calls a specified function for each element in an iterable.\n",
    "# Example: make a list of squares of each number in a tuple\n",
    "\n",
    "def myfunc(n):\n",
    "  return n ** 2\n",
    "\n",
    "result = list(map(myfunc, (5,8,2.5,6,4,3.5))) \n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22, 10, 24, 18, 6, 20]\n"
     ]
    }
   ],
   "source": [
    "# You can use a lambda function with map()\n",
    "\n",
    "nums = [11,5,12,9,3,10]\n",
    "doubled = map(lambda x:x * 2, nums)\n",
    "print(list(doubled))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use built-in str() function and range()\n",
    "# to get a list of integers as strings\n",
    "\n",
    "list_str = list(map(str,range(10,21)))\n",
    "list_str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[25, 40, 55]\n"
     ]
    }
   ],
   "source": [
    "# You can pass multiple sequences to map()\n",
    "\n",
    "result = map(lambda a,b: a + b, (5,10,15),(20,30,40))\n",
    "print(list(result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## split() and join()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['When', 'in', 'the', 'Course', 'of', 'human', 'events']\n",
      "['it', 'becomes', 'necessary', 'for', 'one', 'people']\n",
      "When in the Course of human events\n",
      "Edgar***Allan***Poe\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'dim1 x dim2 x dim3'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The split() function splits a string and returns a list of strings.\n",
    "# General format: my_list = string.split(separator, max_elements)\n",
    "# If separator is omitted, it is a space by default.\n",
    "# max_elements specifies max. elements for list, no limit if omitted.\n",
    "\n",
    "declared = 'When in the Course of human events'\n",
    "words = declared.split()\n",
    "print(words)\n",
    "\n",
    "print('it##becomes##necessary##for##one##people'.split('##'))\n",
    "\n",
    "# join() uses a specified separator string to\n",
    "# makes a larger string from an iterable sequence.\n",
    "# General format: 'sep_string'.join(iterable)\n",
    "\n",
    "# joining list elements into a string\n",
    "my_str = ' '.join(words)  # using space separator and words list from above\n",
    "print(my_str)\n",
    "\n",
    "print('***'.join(['Edgar','Allan','Poe']))\n",
    "\n",
    "# When using a dictionary as the iterable, the KEYS are joined.\n",
    "my_dict = {'dim1':10, 'dim2':8, 'dim3':5}\n",
    "' x '.join(my_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The enumerate() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "breakfast lunch dinner snack "
     ]
    }
   ],
   "source": [
    "# enumerate(iterable,start) adds a counter to an iterable and returns an enumerat\n",
    "# By default start = 0.\n",
    "\n",
    "data = ['breakfast','lunch','dinner','snack']\n",
    "result = list(enumerate(data))                 # default start = 0\n",
    "print(len(result))\n",
    "for n in range(len(result)):\n",
    "    print(result[n][1], end = ' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(-3, 'H'), (-2, 'e'), (-1, 'l'), (0, 'l'), (1, 'o')]\n"
     ]
    }
   ],
   "source": [
    "# example with start value of -3\n",
    "\n",
    "result = enumerate('Hello',start = -3)\n",
    "print(list(result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## chr() and ord() functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A B C D E \n",
      "Some Cherokee Characters: Ꮔ Ꮕ Ꮖ Ꮗ Ꮘ \n",
      "a : 97\n",
      "b : 98\n",
      "c : 99\n",
      "d : 100\n",
      "e : 101\n"
     ]
    }
   ],
   "source": [
    "# to get Unicode character for an integer use chr() function\n",
    "\n",
    "for n in range(65,70):\n",
    "    print(chr(n),end = ' ')\n",
    "    \n",
    "print('\\nSome Cherokee Characters:',end = ' ')\n",
    "    \n",
    "for n in range(5060,5065):\n",
    "    print(chr(n),end = ' ')    \n",
    "    \n",
    "print()\n",
    "\n",
    "# to get integer value for a Unicode character, use ord() function\n",
    "\n",
    "text = 'abcde'\n",
    "for ch in text:\n",
    "    print(ch,':',ord(ch))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other Python Tricks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 15 and b = 10\n",
      "2 3 1\n"
     ]
    }
   ],
   "source": [
    "# swapping values of variables, no need for a 3rd temp variable\n",
    "a, b = 10, 15                    # why use two statements?\n",
    "a, b = b, a                      # this does the swap\n",
    "print('a =',a,'and b =',b)\n",
    "\n",
    "# you can even swap / re-assign more than two variables\n",
    "x, y, z = 1, 2, 3\n",
    "x, y, z = y, z, x\n",
    "print(x,y,z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 4, 3, 2, 1]\n",
      "mussoR nav odiuG\n",
      "racecar a palindrome? True\n"
     ]
    }
   ],
   "source": [
    "# reverse a sequence such as list or string\n",
    "\n",
    "nums = [1,2,3,4,5]\n",
    "nums_rev = nums[::-1]\n",
    "print(nums_rev)\n",
    "\n",
    "guru = 'Guido van Rossum'\n",
    "print(guru[::-1])\n",
    "\n",
    "# detect a palindrome\n",
    "text = 'racecar'\n",
    "print(text,'a palindrome?',text == text[::-1])"
   ]
  }
 ],
 "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
}