Lambda, filter, reduce and map.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "http://www.python-course.eu/python3_lambda.php"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "http://www.python-course.eu/python3_list_comprehension.php"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Map function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[97.7, 98.6, 99.5, 100.4, 102.2]\n",
      "[36.5, 37.0, 37.5, 38.00000000000001, 39.0]\n"
     ]
    }
   ],
   "source": [
    "def fahrenheit(T):\n",
    "    return ((9 * T) / 5 + 32)\n",
    "\n",
    "def celsius(T):\n",
    "    return (5 / 9) * (T - 32)\n",
    "\n",
    "temperatures = (36.5, 37, 37.5, 38, 39)\n",
    "F = map(fahrenheit, temperatures)\n",
    "C = map(celsius, F)\n",
    "\n",
    "temperatures_in_Fahrenheit = list(F)\n",
    "temperatures_in_Celsius = list(map(celsius, temperatures_in_Fahrenheit))\n",
    "print(temperatures_in_Fahrenheit)\n",
    "print(temperatures_in_Celsius)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[39.2, 36.5, 37.3, 38, 37.8]\n",
      "[102.56, 97.7, 99.14, 100.4, 100.03999999999999]\n",
      "[39.2, 36.5, 37.3, 38.0, 37.79999999999999]\n"
     ]
    }
   ],
   "source": [
    "#using lambda\n",
    "\n",
    "C = [39.2, 36.5, 37.3, 38, 37.8] \n",
    "print(C)\n",
    "F = list(map(lambda x: (9 / 5) * x + 32, C))\n",
    "print(F)\n",
    "C = list(map(lambda x: (x - 32) * 5 / 9, F))\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[18, 14, 14, 14]\n",
      "[17, 10, 19, 23]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3,4]\n",
    "b = [17,12,11,10]\n",
    "c = [-1,-4,5,9]\n",
    "\n",
    "print(list(map(lambda x, y: x + y, a, b)))\n",
    "print(list(map(lambda x, y, z: x + y + z, a, b, c)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Mapping a List of Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from math import sin, cos, tan, pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.2246467991473532e-16, -1.0, -1.2246467991473532e-16]\n",
      "Wall time: 1 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "def map_functions(x, functions):\n",
    "    \"\"\"map an iterable of functions on the object x\"\"\"\n",
    "    res = []\n",
    "    for func in functions:\n",
    "        res.append(func(x))\n",
    "    return res\n",
    "\n",
    "family_of_functions = (sin, cos, tan)\n",
    "print(map_functions(pi, family_of_functions))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.2246467991473532e-16, -1.0, -1.2246467991473532e-16]\n",
      "Wall time: 0 ns\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "#With list comprehension\n",
    "\n",
    "def map_functions(x, functions):\n",
    "    return [ func(x) for func in functions]\n",
    "\n",
    "print(map_functions(pi, (sin, cos, tan)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Filtering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 3, 2, 4])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.random.random_integers(0, 10, 10)\n",
    "b = a < 5\n",
    "c = a[b]\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([ True, False,  True, False,  True, False, False, False, False,  True], dtype=bool)]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([3, 3, 2, 4])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print([a < 5])\n",
    "d = a[a < 5]\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 3, 5, 13, 21, 55]\n",
      "[0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1]\n",
      "[False, True, True, False, True, True, False, True, True, False, True]\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "only integer arrays with one element can be converted to an index",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-44-78965f389cc2>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mx\u001b[0m \u001b[1;33m%\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mfibonacci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mx\u001b[0m \u001b[1;33m%\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mfibonacci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfibonacci\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: only integer arrays with one element can be converted to an index"
     ]
    }
   ],
   "source": [
    "fibonacci = [0,1,1,2,3,5,8,13,21,34,55]\n",
    "odd_numbers = list(filter(lambda x: x % 2, fibonacci))\n",
    "print(odd_numbers)\n",
    "\n",
    "\n",
    "e = [x % 2 == 1 for x in fibonacci]\n",
    "print([x % 2 for x in fibonacci])\n",
    "print([x % 2 == 1 for x in fibonacci])\n",
    "print(fibonacci[a])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 8, 34]\n",
      "[True, False, False, True, False, False, True, False, False, True, False]\n",
      "[0, 2, 8, 34]\n",
      "[-1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0]\n"
     ]
    }
   ],
   "source": [
    "even_numbers = list(filter(lambda x: x % 2 == 0, fibonacci))\n",
    "print(even_numbers)\n",
    "\n",
    "print([x % 2 == 0 for x in fibonacci])\n",
    "\n",
    "\n",
    "#or alternatively\n",
    "even_numbers = list(filter(lambda x: x % 2 - 1, fibonacci))\n",
    "print(even_numbers)\n",
    "print([x % 2 - 1 for x in fibonacci])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from functools import reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(lambda x, y: x if (x > y) else y, [1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4950"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(lambda x, y: x + y, range(1,100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ex 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['34587', 'Learning Python, Mark Lutz', 4, 40.95],\n",
       " ['98762', 'Programming Python, Mark Lutz', 5, 56.8],\n",
       " ['77226', 'Head First Python, Paul Barry', 3, 32.95],\n",
       " ['88112', 'EinfĆ¼hrung in Python3, Bernd Klein', 3, 24.99]]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "orders = [ [\"34587\", \"Learning Python, Mark Lutz\", 4, 40.95], \n",
    "           [\"98762\", \"Programming Python, Mark Lutz\", 5, 56.80], \n",
    "           [\"77226\", \"Head First Python, Paul Barry\", 3,32.95],\n",
    "           [\"88112\", \"EinfĆ¼hrung in Python3, Bernd Klein\", 3, 24.99]]\n",
    "orders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "min_order = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "160"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = lambda quantity, price: quantity * price + 10 if (quantity*price < min_order) \\\n",
    "            else quantity * price\n",
    "f(4, 40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['34587', '98762', '77226', '88112']"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[order[0] for order in orders]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def tupleOrders(l):\n",
    "    return (l[0], f(l[2], l[3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('34587', 163.8),\n",
       " ('98762', 284.0),\n",
       " ('77226', 108.85000000000001),\n",
       " ('88112', 84.97)]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(tupleOrders, orders))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('34587', 163.8),\n",
       " ('98762', 284.0),\n",
       " ('77226', 108.85000000000001),\n",
       " ('88112', 84.97)]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# solution by the site\n",
    "\n",
    "invoice_totals = list(map(lambda x: x if x[1] >= min_order else (x[0], x[1] + 10), map(lambda x: (x[0],x[2] * x[3]), orders)))\n",
    "\n",
    "invoice_totals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('34587', 163.8),\n",
       " ('98762', 284.0),\n",
       " ('77226', 98.85000000000001),\n",
       " ('88112', 74.97)]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_orders = list(map(lambda x: (x[0],x[2] * x[3]), orders))\n",
    "first_orders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('34587', 163.8),\n",
       " ('98762', 284.0),\n",
       " ('77226', 108.85000000000001),\n",
       " ('88112', 84.97)]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "invoice_totals = list(map(lambda x: x if x[1] >= 100 else (x[0], x[1] + 10), first_orders))\n",
    "invoice_totals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ex 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, ('5464', 4, 9.99), ('8274', 18, 12.99), ('9744', 9, 44.95)],\n",
       " [2, ('5464', 9, 9.99), ('9744', 9, 44.95)],\n",
       " [3, ('5464', 9, 9.99), ('88112', 11, 24.99)],\n",
       " [4, ('8732', 7, 11.99), ('7733', 11, 18.99), ('88112', 5, 39.95)]]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "orders = [ [1, (\"5464\", 4, 9.99), (\"8274\",18,12.99), (\"9744\", 9, 44.95)], \n",
    "\t       [2, (\"5464\", 9, 9.99), (\"9744\", 9, 44.95)],\n",
    "\t       [3, (\"5464\", 9, 9.99), (\"88112\", 11, 24.99)],\n",
    "           [4, (\"8732\", 7, 11.99), (\"7733\",11,18.99), (\"88112\", 5, 39.95)] ]\n",
    "orders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "map() must have at least two arguments.",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-60-d74198add74c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmap\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: map() must have at least two arguments."
     ]
    }
   ],
   "source": [
    "list(map())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('5464', 39.96)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = ('5464', 4, 9.99)\n",
    "x[0], x[1] * x[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 39.96, 233.82, 404.55], [2, 89.91, 404.55], [3, 89.91, 274.89], [4, 83.93, 208.89, 199.75]]\n",
      "[[1, 678.3299999999999], [2, 494.46000000000004], [3, 364.79999999999995], [4, 492.57]]\n",
      "[[1, 678.3299999999999], [2, 494.46000000000004], [3, 364.79999999999995], [4, 492.57]]\n"
     ]
    }
   ],
   "source": [
    "orders = [ [1, (\"5464\", 4, 9.99), (\"8274\",18,12.99), (\"9744\", 9, 44.95)], \n",
    "\t       [2, (\"5464\", 9, 9.99), (\"9744\", 9, 44.95)],\n",
    "\t       [3, (\"5464\", 9, 9.99), (\"88112\", 11, 24.99)],\n",
    "           [4, (\"8732\", 7, 11.99), (\"7733\",11,18.99), (\"88112\", 5, 39.95)] ]\n",
    "\n",
    "min_order = 100\n",
    "invoice_totals = list(map(lambda x: [x[0]] + list(map(lambda y: y[1]*y[2], x[1:])), orders))\n",
    "print (invoice_totals)\n",
    "invoice_totals = list(map(lambda x: [x[0]] + [reduce(lambda a,b: a + b, x[1:])], invoice_totals))\n",
    "print (invoice_totals)\n",
    "invoice_totals = list(map(lambda x: x if x[1] >= min_order else (x[0], x[1] + 10), invoice_totals))\n",
    "\n",
    "print (invoice_totals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 39.96, 233.82, 404.55], [2, 89.91, 404.55], [3, 89.91, 274.89], [4, 83.93, 208.89, 199.75]]\n"
     ]
    }
   ],
   "source": [
    "invoice_totals = list(map(lambda x: [x[0]] + list(map(lambda y: y[1]*y[2], x[1:])), orders))\n",
    "print (invoice_totals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, ('5464', 4, 9.99), ('8274', 18, 12.99), ('9744', 9, 44.95)],\n",
       " [2, ('5464', 9, 9.99), ('9744', 9, 44.95)],\n",
       " [3, ('5464', 9, 9.99), ('88112', 11, 24.99)],\n",
       " [4, ('8732', 7, 11.99), ('7733', 11, 18.99), ('88112', 5, 39.95)]]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "orders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[39.96, 233.82, 404.55],\n",
       " [89.91, 404.55],\n",
       " [89.91, 274.89],\n",
       " [83.93, 208.89, 199.75]]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: list(map(lambda y: y[1]*y[2], x[1:])), orders))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 39.96, 233.82, 404.55],\n",
       " [2, 89.91, 404.55],\n",
       " [3, 89.91, 274.89],\n",
       " [4, 83.93, 208.89, 199.75]]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "invoice_xoel = list(map(lambda x: [x[0]] + list(map(lambda y: y[1]*y[2],   x[1:])), orders))\n",
    "invoice_xoel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 678.3299999999999],\n",
       " [2, 494.46000000000004],\n",
       " [3, 364.79999999999995],\n",
       " [4, 492.57]]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "invoice_xoel = list(map(lambda x: [x[0]] + [reduce(lambda a, b: a + b , x[1:])], invoice_xoel))\n",
    "invoice_xoel"
   ]
  }
 ],
 "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.4.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}