3. DIP_adv_Python_Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Broadcast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[  2.4,   8.7,  31.2],\n",
       "       [157.2,  70.8, 292. ],\n",
       "       [165.6,  95.1, 191.2],\n",
       "       [ 43.2,  33. ,  39.2]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "macros = np.array([ \n",
    "[0.8, 2.9, 3.9], \n",
    "[52.4, 23.6, 36.5], \n",
    "[55.2, 31.7, 23.9], \n",
    "[14.4, 11, 4.9] \n",
    "]) \n",
    "print(macros.shape)\n",
    "# Create a new array filled with zeros, \n",
    "# of the same shape as macros. \n",
    "result = np.zeros_like(macros) \n",
    "\n",
    "cal_per_macro = np.array([3, 3, 8]) \n",
    "\n",
    "# Now multiply each row of macros by \n",
    "# cal_per_macro. In Numpy, `*` is \n",
    "# element-wise multiplication between two arrays. \n",
    "for i in range(macros.shape[0]): \n",
    "\tresult[i, :] = macros[i, :] * cal_per_macro \n",
    "\n",
    "result \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11 22 33]\n",
      " [10 20 30]]\n",
      "4\n",
      "[[15 26 37]\n",
      " [14 24 34]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "A = np.array([[11, 22, 33], [10, 20, 30]]) \n",
    "print(A) \n",
    "\n",
    "b = 4\n",
    "print(b) \n",
    "\n",
    "C = A + b \n",
    "print(C) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# New axis usage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((3, 2), (3,))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.ones((3, 2))\n",
    "a = np.arange(3)\n",
    "M.shape, a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (3,2) (3,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-8cac1d547906>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,2) (3,) "
     ]
    }
   ],
   "source": [
    "M + a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:, np.newaxis].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [2., 2.],\n",
       "       [3., 3.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M + a[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Zip functionality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The zipped result is : [('Manjeet', 4, 40), ('Nikhil', 1, 50), ('Shambhavi', 3, 60), ('Astha', 2, 70)]\n",
      "\n",
      "\n",
      "The unzipped result: \n",
      "The name list is : ('Manjeet', 'Nikhil', 'Shambhavi', 'Astha')\n",
      "The roll_no list is : (4, 1, 3, 2)\n",
      "The marks list is : (40, 50, 60, 70)\n"
     ]
    }
   ],
   "source": [
    "# Python code to demonstrate the working of \n",
    "# unzip \n",
    "\n",
    "# initializing lists \n",
    "\n",
    "name = [ \"Manjeet\", \"Nikhil\", \"Shambhavi\", \"Astha\" ] \n",
    "roll_no = [ 4, 1, 3, 2 ] \n",
    "marks = [ 40, 50, 60, 70 ] \n",
    "\n",
    "# using zip() to map values \n",
    "mapped = zip(name, roll_no, marks)\n",
    "#print(mapped)\n",
    "\n",
    "# converting values to print as list \n",
    "mapped = list(mapped) \n",
    "\n",
    "# printing resultant values \n",
    "print (\"The zipped result is : \",end=\"\") \n",
    "print (mapped) \n",
    "\n",
    "print(\"\\n\") \n",
    "\n",
    "# unzipping values \n",
    "namz, roll_noz, marksz = zip(*mapped) \n",
    "\n",
    "print (\"The unzipped result: \\n\",end=\"\") \n",
    "\n",
    "# printing initial lists \n",
    "print (\"The name list is : \",end=\"\") \n",
    "print (namz) \n",
    "\n",
    "print (\"The roll_no list is : \",end=\"\") \n",
    "print (roll_noz) \n",
    "\n",
    "print (\"The marks list is : \",end=\"\") \n",
    "print (marksz) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# try and except in Python\n",
    "\n",
    "## try() is used in Error and Exception Handling \n",
    "### There are two kinds of errors :\n",
    "\n",
    "### Syntax Error : Also known as Parsing Errors, most basic. Arise when the Python parser is unable to understand a line of code.\n",
    "### Exception : Errors which are detected during execution. eg – ZeroDivisionError.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorry ! You are dividing by zero \n"
     ]
    }
   ],
   "source": [
    "# Python code to illustrate \n",
    "# working of try() \n",
    "def divide(x, y): \n",
    "\ttry: \n",
    "\t\t# Floor Division : Gives only Fractional Part as Answer \n",
    "\t\tresult = x // y \n",
    "\t\tprint(\"Yeah ! Your answer is :\", result) \n",
    "\texcept ZeroDivisionError: \n",
    "\t\tprint(\"Sorry ! You are dividing by zero \") \n",
    "\n",
    "# Look at parameters and note the working of Program \n",
    "divide(3, 0) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Charlie': 12, 'Tim': 18, 'Robert': 25}\n",
      "{'Tiffany': 22}\n"
     ]
    }
   ],
   "source": [
    "Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}\t\n",
    "Boys = {'Tim': 18,'Charlie':12,'Robert':25}\n",
    "Girls = {'Tiffany':22}\t\n",
    "studentX=Boys.copy()\n",
    "studentY=Girls.copy()\n",
    "print(studentX)\n",
    "print(studentY)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Tiffany': 22, 'Charlie': 12, 'Robert': 25, 'Sarah': 9, 'Tim': 18}\n"
     ]
    }
   ],
   "source": [
    "Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}\t\n",
    "Dict.update({\"Sarah\":9})\n",
    "print(Dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Tiffany': 22, 'Robert': 25, 'Sarah': 9, 'Tim': 18}\n"
     ]
    }
   ],
   "source": [
    "#Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}\t\n",
    "del Dict ['Charlie']\n",
    "print(Dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Students Name: [('Tiffany', 22), ('Charlie', 12), ('Robert', 25), ('Tim', 18)]\n"
     ]
    }
   ],
   "source": [
    "Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}\t\n",
    "print(\"Students Name: %s\" % list(Dict.items()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Check if a given key already exists in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}\n",
    "Boys = {'Tim': 18,'Charlie':12,'Robert':25}\n",
    "Girls = {'Tiffany':22}\n",
    "for key in list(Dict.keys()):\n",
    "    if key in list(Boys.keys()):\n",
    "        print(True)\n",
    "    else:       \n",
    "        print(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# where"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "Indices of elements <4\n",
      "(array([0, 0, 0]), array([0, 1, 2]))\n",
      "Elements which are <4\n",
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "# Python program explaining \n",
    "# where() function \n",
    "\n",
    "import numpy as np \n",
    "\n",
    "# a is an array of integers. \n",
    "a = np.array([[1, 2, 3], [4, 5, 6]]) \n",
    "\n",
    "print(a) \n",
    "\n",
    "print ('Indices of elements <4') \n",
    "\n",
    "b = np.where(a<4) \n",
    "print(b) \n",
    "\n",
    "print(\"Elements which are <4\") \n",
    "print(a[b]) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: \n",
      "[[0.70209213 0.15268629 0.24840691 0.63196036 0.64226182 0.8304314\n",
      "  0.38562548 0.4827599  0.01821125 0.84658639]]\n",
      "result: \n",
      "[[1 0 0 1 1 1 0 0 0 1]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "a = (np.random.rand(1,10)) #create a random (1,10) array\n",
    "print (\"a: \\n\" + str(a))\n",
    "result = (np.where(a>0.5,1,0)) \n",
    "print (\"result: \\n\" +str(result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# enumerate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'eat')\n",
      "(1, 'sleep')\n",
      "(2, 'repeat')\n",
      "100 eat\n",
      "101 sleep\n",
      "102 repeat\n"
     ]
    }
   ],
   "source": [
    "# Python program to illustrate \n",
    "# enumerate function in loops \n",
    "l1 = [\"eat\",\"sleep\",\"repeat\"] \n",
    "\n",
    "# printing the tuples in object directly \n",
    "for ele in enumerate(l1): \n",
    "\tprint(ele) \n",
    "print\n",
    "# changing index and printing separately \n",
    "for count,ele in enumerate(l1,100): \n",
    "\tprint(count,ele) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "343\n",
      "125\n"
     ]
    }
   ],
   "source": [
    "# Python code to illustrate cube of a number \n",
    "# showing difference between def() and lambda(). \n",
    "def cube(y): \n",
    "\treturn y*y*y; \n",
    "\n",
    "g = lambda x: x*x*x \n",
    "print(g(7)) \n",
    "\n",
    "print(cube(5)) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "# Python program to demonstrate working \n",
    "# of map. \n",
    "\n",
    "# Return double of n \n",
    "def addition(n): \n",
    "\treturn n + n \n",
    "\n",
    "# We double all numbers using map() \n",
    "numbers = (1, 2, 3, 4) \n",
    "result = map(addition, numbers) \n",
    "print(list(result)) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "193\n"
     ]
    }
   ],
   "source": [
    "# Python code to illustrate \n",
    "# reduce() with lambda() \n",
    "# to get sum of a list \n",
    "from functools import reduce\n",
    "li = [5, 8, 10, 20, 50, 100] \n",
    "sum = reduce((lambda x, y: x + y), li) \n",
    "print (sum) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "# Double all numbers using map and lambda \n",
    "\n",
    "numbers = (1, 2, 3, 4) \n",
    "result = map(lambda x: x + x, numbers) \n",
    "print(list(result)) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "# Add two lists using map and lambda \n",
    "\n",
    "numbers1 = [1, 2, 3] \n",
    "numbers2 = [4, 5, 6] \n",
    "\n",
    "result = map(lambda x, y: x + y, numbers1, numbers2) \n",
    "print(list(result)) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# vstack and hstack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f = np.array([1,2,3])[:,np.newaxis]\n",
    "g = np.array([4,5,6])[:,np.newaxis]\n",
    "print(f.shape,g.shape)\n",
    "print('Horizontal Append:', np.hstack((f, g)),np.hstack((f, g)).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vertically Append: [[1]\n",
      " [2]\n",
      " [3]\n",
      " [4]\n",
      " [5]\n",
      " [6]] (6, 1)\n"
     ]
    }
   ],
   "source": [
    "print('vertically Append:', np.vstack((f, g)),np.vstack((f, g)).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# np.dot vs np.inner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[37, 40],\n",
       "        [85, 92]]), array([[35, 41],\n",
       "        [81, 95]]))"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> a=np.array([[1,2],[3,4]])\n",
    ">>> b=np.array([[11,12],[13,14]])\n",
    ">>> np.dot(a,b), np.inner(a,b)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[11 12]\n",
      " [13 14]]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Break statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number is 1\n",
      "Number is 2\n",
      "Number is 3\n",
      "Number is 4\n",
      "Out of loop\n"
     ]
    }
   ],
   "source": [
    "number = 0\n",
    "\n",
    "for number in range(10):\n",
    "    number = number + 1\n",
    "\n",
    "    if number == 5:\n",
    "        break    # break here\n",
    "\n",
    "    print('Number is ' + str(number))\n",
    "\n",
    "print('Out of loop')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Continue Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number is 1\n",
      "Number is 2\n",
      "Number is 3\n",
      "Number is 4\n",
      "Number is 6\n",
      "Number is 7\n",
      "Number is 8\n",
      "Number is 9\n",
      "Number is 10\n",
      "Out of loop\n"
     ]
    }
   ],
   "source": [
    "number = 0\n",
    "\n",
    "for number in range(10):\n",
    "    number = number + 1\n",
    "\n",
    "    if number == 5:\n",
    "        continue    # continue here\n",
    "\n",
    "    print('Number is ' + str(number))\n",
    "\n",
    "print('Out of loop')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# assert Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average of mark1: 10.0\n"
     ]
    }
   ],
   "source": [
    "def avg(marks):\n",
    "    assert len(marks) != 0\n",
    "    return sum(marks)/len(marks)\n",
    "\n",
    "mark1 = [10]\n",
    "print(\"Average of mark1:\",avg(mark1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# global statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "globvar = 10\n",
    "def read1():\n",
    "    print(globvar)\n",
    "def write1():\n",
    "    global globvar\n",
    "    globvar = 5\n",
    "def write2():\n",
    "    globvar = 15\n",
    "\n",
    "read1()\n",
    "\n",
    "write1()\n",
    "\n",
    "read1()\n",
    "\n",
    "write2()\n",
    "\n",
    "read1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# transpose of 3D matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1  2  3  4]\n",
      "  [ 5  6  7  8  9]]\n",
      "\n",
      " [[10 11 12 13 14]\n",
      "  [15 16 17 18 19]]\n",
      "\n",
      " [[20 21 22 23 24]\n",
      "  [25 26 27 28 29]]]\n",
      "(3, 2, 5)\n"
     ]
    }
   ],
   "source": [
    "x_test = np.arange(30).reshape(3, 2, 5)\n",
    "\n",
    "print(x_test)\n",
    "print(x_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  5]\n",
      "  [ 1  6]\n",
      "  [ 2  7]\n",
      "  [ 3  8]\n",
      "  [ 4  9]]\n",
      "\n",
      " [[10 15]\n",
      "  [11 16]\n",
      "  [12 17]\n",
      "  [13 18]\n",
      "  [14 19]]\n",
      "\n",
      " [[20 25]\n",
      "  [21 26]\n",
      "  [22 27]\n",
      "  [23 28]\n",
      "  [24 29]]]\n",
      "(3, 5, 2)\n"
     ]
    }
   ],
   "source": [
    "y = np.transpose(x_test, (0, 2, 1))\n",
    "print(y)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}