28-June-19.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# set practice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "67\n",
      "3\n",
      "4\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "s=set([1,2,3,4,3,2,67,6])\n",
    "for i in s:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 6, 23, 67}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.add(23)\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 23, 3, 4, 6, 67, 'hello', 'hii'}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.update([\"hii\",\"hello\"])\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.discard(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 23, 4, 6, 67, 'hello', 'hii'}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 4, 6}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b=set([1,2,4,6])\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.issubset(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.issuperset(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 23, 4, 6, 67, 'hello', 'hii'}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=s.copy()\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 23, 4, 6, 67, 'hello', 'hii'}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 7, 9, 45, 89, 99}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=set([9,7,4,89,45,99])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Map Functionality\n",
    "### Mapping -->relational values,mapping Entity  between Function"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "y=f(x)\n",
    "       f:x^2\n",
    " x     y\n",
    " 1     1\n",
    " 2     4\n",
    " 3     9\n",
    " 4     16\n",
    " 5     25\n",
    " map(function,Iterable)\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# function to return power of value in diffent types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def powerofn(a,n):\n",
    "    return (a**n)\n",
    "powerofn(4,2)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def power1(a,n):\n",
    "    result=1 # when ever power,factorial intial value is =1 i,e=a power 0  is 1\n",
    "    for i in range(0,n): #range is from 0\n",
    "        result*=a\n",
    "    return result\n",
    "power1(4,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def recursivepowerN(a,n): #This is a Python Program to find the power of a number using recursion. ... \n",
    "                                    #If the exponential power isn't equal to 1, \n",
    "                            #return the base number multiplied with the power function called recursively with the arguments as\n",
    "                                    #the base and power minus 1.\n",
    "    if n==0:\n",
    "        return 1\n",
    "    else:\n",
    "        return a*recursivepowerN(a,n-1)\n",
    "recursivepowerN(4,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# functions for return cubes in different ways by map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def cubes(n):\n",
    "    return n**3\n",
    "cubes(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{64, 1, 8, 216, 27}\n",
      "{8}\n"
     ]
    }
   ],
   "source": [
    "def cubes1(n):\n",
    "    return n**3\n",
    "l=[1,2,3,4,3,2,6]\n",
    "print(set((map(cubes,l)))) #  return all elements  cubes in alist\n",
    "print(set(map(cubes,[2]))) #return 2 cube"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# data comprehension=data tyep convestion from one to another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 32]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "li=['2','4','32']\n",
    "list(map(int,li)) #convert strings in a list  into a integers by using map function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '10']\n",
      "[1.0, 10.0]\n"
     ]
    }
   ],
   "source": [
    "print(list(map(str,l))) #converts integers into strings\n",
    "print(list(map(float,l)))  # return float values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 10)\n"
     ]
    }
   ],
   "source": [
    "x=print(tuple(map(int,l)))  #constant values==assigned to tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 10]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " list(int(i) for i in l) #by list comprehension convert integers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 5]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "li=[1,2,'a',5,'j']\n",
    "def isdigit1(c):\n",
    "    c=str(c)\n",
    "    if c.isdigit():\n",
    "        return True\n",
    "    return False\n",
    "print(isdigit1('1'))\n",
    "print(isdigit1('d'))\n",
    "list(filter(isdigit1,li))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# checking all strings in a list by filter by reversing the isdigit() logic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['a', 'j']"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "li=[1,2,'a',5,'j']\n",
    "def isdigit1(c):\n",
    "    c=str(c)\n",
    "    if c.isdigit():\n",
    "        return 0\n",
    "    return 1\n",
    "print(isdigit1('1'))\n",
    "print(isdigit1('d'))\n",
    "list(filter(isdigit1,li))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# identify all primes in a range using filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 5, 7, 11, 13]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "l=[1,10]\n",
    "def isprime(n): #prime numbers starts from 2,3,5,7\n",
    "    if n<2:\n",
    "        return False\n",
    "    for i in range(2,n//2+1):\n",
    "        #print(i)\n",
    "        if n%i==0:\n",
    "            return False\n",
    "    return True\n",
    "lb,ub=1,15\n",
    "lst=list(filter(isprime,range(lb,ub+1))) #return the primes numbers in alist with in a 1-15\n",
    "lst    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 5, 7, 11, 13]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(i for i in range(1,15) if isprime(i)) #by list comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lambda"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "> Anonymous Functions\n",
    ">can be embedded in to List comprehension,maps,Filters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "a=lambda x: x*2\n",
    "print(a(2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 8, 27, 64, 125]\n"
     ]
    }
   ],
   "source": [
    "print(list(map(lambda x:x**3,[1,2,3,4,5])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda x:(x%2==0),[1,2,3,4,5])) #for even numbers in a list (1-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda x:(x%2!=0),[1,2,3,4,5]))# for odd numbers in 1-5 range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# generate a student marks and calculate average with lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8.5, 7.0, 14.0, 4.5, 22.5, 14.0, 18.0, 7.0, 9.0, 20.5]"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from random import randint\n",
    "internal1=[randint(0,25) for i in range(10)]\n",
    "internal2=[randint(0,25) for i in range(10)]\n",
    "avginternals=list(map(lambda  x,y:(x+y)/2,internal1,internal2))\n",
    "avginternals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # for only floor values with 3 inputs of lambda"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "internal1=[randint(0,25) for i in range(10)]\n",
    "internal2=[randint(0,25) for i in range(10)]\n",
    "inter3=[randint(0,25) for i in range(10)]\n",
    "avginternals=list(map(lambda  x,y,z:(x+y+z)//3,internal1,internal2,inter3))\n",
    "avginternals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# findout the failed students by filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 3, 8, 5]"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avginternals=list(filter(lambda x:x<10,avginternals))\n",
    "avginternals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Apply Functional programming to the marks analysis application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generate  Marks data\n",
    "from random import randint\n",
    "def generatemarks(n,lb,ub):\n",
    "    filename=\"data files/newmarks.txt\"\n",
    "    with open(filename,'w') as f:\n",
    "        for i in range(n):\n",
    "            marks=randint(lb,ub)\n",
    "            f.write(str(marks)+'\\n')\n",
    "        return\n",
    "generatemarks(50,0,100)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# class average\n",
    "# %of failed %of passed \n",
    "# %of frequency of highest and lowest marks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[26, 41, 56, 47, 59, 30, 86, 94, 48, 19, 20, 25, 39, 34, 53, 79, 48, 83, 23, 16, 61, 24, 88, 5, 92, 53, 39, 38, 0, 81, 56, 75, 84, 6, 42, 29, 24, 96, 15, 62, 82, 0, 31, 39, 77, 32, 32, 19, 31, 96]\n"
     ]
    }
   ],
   "source": [
    "def readmarkslist(filename):\n",
    "    with open(filename,'r') as f:\n",
    "        x=f.read().split()\n",
    "    return list(map(int,x))\n",
    "print(readmarkslist(filename))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[26, 41, 56, 47, 59, 30, 86, 94, 48, 19, 20, 25, 39, 34, 53, 79, 48, 83, 23, 16, 61, 24, 88, 5, 92, 53, 39, 38, 0, 81, 56, 75, 84, 6, 42, 29, 24, 96, 15, 62, 82, 0, 31, 39, 77, 32, 32, 19, 31, 96]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "46"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re\n",
    "def classavg(filename):\n",
    "    markslist=readmarkslist(filename)\n",
    "    print(markslist)\n",
    "    return sum(markslist)//len(markslist)\n",
    "filename=\"data files/newmarks.txt\"\n",
    "classavg(filename)           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def percentfailed(filename):\n",
    "    failed=readmarkslist(filename)\n",
    "    return len(list(filter(lambda  marks: marks<35,failed)))\n",
    "percentfailed(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def percentpassed(filename):\n",
    "    passed=readmarkslist(filename)\n",
    "    return len(list(filter(lambda  marks: marks>35,passed)))\n",
    "percentpassed(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def percentdistinction(filename):\n",
    "    dist=readmarkslist(filename)\n",
    "    return len(list(filter(lambda  marks: marks>75,dist)))\n",
    "percentdistinction(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 96]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def highestmarks(filename):\n",
    "    markslist=readmarkslist(filename)\n",
    "    return [markslist.count(max(markslist)),max(markslist)]\n",
    "highestmarks(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 0]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def lowestmarks(filename):\n",
    "    markslist=readmarkslist(filename)\n",
    "    return [markslist.count(min(markslist)),min(markslist)]\n",
    "lowestmarks(filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Encryption"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "key-Mapping of characters with replace\n",
    "0 1 2 3 4 5 6 7 8 9 #key\n",
    "4 5 6 7 8 9 0 1 2 3 #changeable key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function to generate key for encryption"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "keypath=\"data files/key.txt\"\n",
    "def generatekey(keypath):\n",
    "    with open(keypath,'w') as f:\n",
    "        for i in range(10):\n",
    "            if i<6:\n",
    "                f.write(str(i)+' '+str(i+4)+'\\n')\n",
    "            else:\n",
    "                f.write(str(i)+' '+str(i-6)+'\\n')\n",
    "    return \n",
    "generatekey(keypath)            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# construct a dictionary for  key data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0': '4',\n",
       " '1': '5',\n",
       " '2': '6',\n",
       " '3': '7',\n",
       " '4': '8',\n",
       " '5': '9',\n",
       " '6': '0',\n",
       " '7': '1',\n",
       " '8': '2',\n",
       " '9': '3'}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "def constructkeyfile(keyfile):\n",
    "    d={}\n",
    "    with open(keyfile,'r') as f:\n",
    "        for i in f:\n",
    "            i=i.split()\n",
    "            d[i[0]]=i[1]\n",
    "    return d\n",
    "keyfile=\"data files/key.txt\"\n",
    "constructkeyfile(keyfile)        "
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}