Skip to content

Instantly share code, notes, and snippets.

@Jessime

Jessime/Introduction.ipynb

Created June 9, 2016 20:35
Show Gist options
  • Save Jessime/cf8090bc033b6abb1b12429097b643da to your computer and use it in GitHub Desktop.
Save Jessime/cf8090bc033b6abb1b12429097b643da to your computer and use it in GitHub Desktop.
Download ZIP
Display the source blob
Display the rendered blob
Raw
Introduction.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"toc": "true"
},
"source": [
"# Table of Contents\n",
" <p><div class=\"lev1\"><a href=\"#Introduction-to-the-Console\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Introduction to the Console</a></div><div class=\"lev1\"><a href=\"#Introduction-to-Scripts\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Introduction to Scripts</a></div><div class=\"lev1\"><a href=\"#Introduction-to-Methods\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Introduction to Methods</a></div>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Introduction to the Console"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Created on Fri Jun 19 11:40:29 2015\n",
"\n",
"@author: Jessime\n",
"\n",
"Description: This is the first lesson for my HTLTC Python small group.\n",
"The order that I'm going to present material may not be completely conventional.\n",
"Instead, I'm going to focus on things that are useful for the project. \n",
"As new topics come up, I'll address them as fully as I can.\n",
"This way, you immediately see why topics we're covering can be useful to you.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The (Ipython) console will evalue commands immediately.\n",
"Try typing some of the following lines into the console and executing them.\n",
"Note the use of different operators."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2+2"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"7-2"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"670592745"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"12345*54321"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"64"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"4**3"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"24/3"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"1/2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"What happens when you run 1/2?\n",
"\n",
"Is it the output you expected?\n",
"What could you do to get a more intuitive answer?\n",
"A few basic types include:\n",
"* integers\n",
"* floats\n",
"* strings\n",
"The Ipython console can do many things than behave like a giant calculator. But I prefer keeping even my simplest of commands in scripts. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Introduction to Scripts "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's try messing around with these types from this script.\n",
"The keyword 'print' will display things written in the script to the console.\n",
"Keywords are just words in the python language that have built in functionality."
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"49\n"
]
}
],
"source": [
"print 12*4+1"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"60\n"
]
}
],
"source": [
"print 12*(4+1) #Check out these order of operations"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The text after the '#' is a comment, and is not evaluated. It's just there to be useful for you and other people reading your code."
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2.4\n"
]
}
],
"source": [
"print 12/5.0 #float type"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello World!\n"
]
}
],
"source": [
"print \"Hello World!\""
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"11.0\n"
]
}
],
"source": [
"print \"11.0\""
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"11.0\n"
]
}
],
"source": [
"print 11.0"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<type 'str'>\n",
"<type 'float'>\n",
"<type 'int'>\n"
]
}
],
"source": [
"print type(\"11.0\") #Check the type of something with the built-in function 'type'\n",
"print type(11.0)\n",
"print type(11)"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello World!\n",
"AAAAAGGTCTCTC\n"
]
}
],
"source": [
"print \"Hello \" + \"World!\" #You can use some operators on strings as well\n",
"print \"A\"*5+\"GG\"+\"TC\"*3"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"collapsed": false
},
"outputs": [
{
"ename": "TypeError",
"evalue": "can't multiply sequence by non-int of type 'float'",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m<ipython-input-55-8b434a0b2ebc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mprint\u001b[0m \u001b[1;34m\"A\"\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m5.0\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'float'"
]
}
],
"source": [
"print \"A\"*5.0"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"What happens when you run the last line; what's the issue?\n",
"\n",
"You need to have an integer. It doesn't make sense to multiply a line 1.3 times.\n",
"Being able to read and address error messages is extremely important.\n",
"\n",
"An extremely powerful concept is being able to store things in variables.\n",
"In python, you do this in an assignment statement."
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"folder = \"C:/Users/Jessime/Code/small_group/\"\n",
"document = \"ex_doc.txt\""
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"C:/Users/Jessime/Code/small_group/ex_doc.txt\n"
]
}
],
"source": [
"print folder+document"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"There are both rules and important guidelines to variable names.\n",
"Rules:\n",
"1. It has to be 1 word\n",
"2. It can only use letters, numbers, and the underscore '_' symbol\n",
"3. It can't start with a number\n",
"\n",
"Guidelines (PEP 8, the style guide for Python, has many more suggestions):\n",
"1. Make variable names informative.\n",
"2. Use words not letters: 'folder' not 'f'\n",
"3. Separate with underscore: 'work_folder' not 'workfolder'\n",
"4. Don't use very similar names: 'work_folder' 'spam_folder' not 'folder1' 'folder2'\n",
"5. Don't name things after types: 'folder' not 'string'\n",
"\n",
"These guidelines become more important as your code grows in complexity.\n",
"For one line commands and trivial scripts they aren't so useful.\n",
"It's easier to start with good habits though.\n",
"\n",
"\n",
"Let's do something mildly useful, then backtrack and see what we did.\n",
"Below is an example of a simple script."
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This is just a short example.\n",
"It contains a few lines. \n",
"Maybe this is a header, and below are some proteins of interest:\n",
"\n",
"SRP\n",
"CBX1\n",
"ESET\n",
"JARID1B\n",
"PRC2\n",
"\n",
"THIS IS JUST A SHORT EXAMPLE.\n",
"IT CONTAINS A FEW LINES. \n",
"MAYBE THIS IS A HEADER, AND BELOW ARE SOME PROTEINS OF INTEREST:\n",
"\n",
"SRP\n",
"CBX1\n",
"ESET\n",
"JARID1B\n",
"PRC2\n",
"\n",
"144\n"
]
}
],
"source": [
"folder = \"C:/Users/Jessime/Code/small_group/\"\n",
"document = \"ex_doc.txt\"\n",
"path = folder+document\n",
"input_file = open(path)\n",
"text = input_file.read()\n",
"print text\n",
"uppercase_text = text.upper() #An unfortunate bug in spyder at the moment.\n",
"print uppercase_text\n",
"print uppercase_text.find(\"PRC2\")\n",
"input_file.close()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Congrats!\n",
"You've just written your first script!\n",
"Let's disect it now. \n",
"We know what the first 3 lines do. \n",
"We've already seen something like line 95, using 'type', but this is the 'open' function.\n",
"What is a function anyway?\n",
"\n",
"A function is just a block of code that performs some task. \n",
"You can tell something is a function when it is followed by parentheses.\n",
"It's like a mini-script. \n",
"Python has provided a few functions that are used very often.\n",
"They're called built-ins.\n",
"You can also write your own functions. \n",
"Doing that will let us get a better sense for how functions actually work.\n",
"The easiest way to do this is to wrap the whole script in a function.\n",
"This is pretty common and will generally speed up your code as well.\n",
"The script wrapped in a funcition would look like:\n"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"def main():\n",
" folder = \"C:/Users/Jessime/Code/small_group/\"\n",
" document = \"ex_doc.txt\"\n",
" path = folder+document\n",
" input_file = open(path)\n",
" text = input_file.read()\n",
" print text\n",
" uppercase_text = text.upper() #An unfortunate bug in spyder at the moment.\n",
" print uppercase_text\n",
" print uppercase_text.find(\"PRC2\")\n",
" input_file.close()\n"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This is just a short example.\n",
"It contains a few lines. \n",
"Maybe this is a header, and below are some proteins of interest:\n",
"\n",
"SRP\n",
"CBX1\n",
"ESET\n",
"JARID1B\n",
"PRC2\n",
"\n",
"THIS IS JUST A SHORT EXAMPLE.\n",
"IT CONTAINS A FEW LINES. \n",
"MAYBE THIS IS A HEADER, AND BELOW ARE SOME PROTEINS OF INTEREST:\n",
"\n",
"SRP\n",
"CBX1\n",
"ESET\n",
"JARID1B\n",
"PRC2\n",
"\n",
"144\n"
]
}
],
"source": [
"main()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The word 'def' is another keyword, which you can think of as 'define'.\n",
"It says, \"below this line, I am defining a function that I am going to name 'main'\".\n",
"To actually utilize the function, you refer to it as a variable, followed by parentheses.\n",
"The parentheses 'call' a function. Another example might better illustrate this. \n",
"Right now, the output of our script is really ugly.\n",
"Lets make a function to beautify our output."
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def show_contents(text):\n",
" print \"\"\n",
" print \"_\"*64\n",
" print \"1. Originial text:\"\n",
" print text\n",
" print \"\"\n",
" uppercase_text = text.upper()\n",
" print \"2. Uppercase text:\"\n",
" print uppercase_text\n",
" print \"\"\n",
" print \"3. Your protein is at position: \"\n",
" print uppercase_text.find(\"PRC2\")\n",
" print \"_\"*64"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def main():\n",
" folder = \"C:/Users/Jessime/Code/small_group/\"\n",
" document = \"ex_doc.txt\"\n",
" path = folder+document\n",
" input_file = open(path)\n",
" text = input_file.read()\n",
" show_contents(text)\n",
" input_file.close()"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"________________________________________________________________\n",
"1. Originial text:\n",
"This is just a short example.\n",
"It contains a few lines. \n",
"Maybe this is a header, and below are some proteins of interest:\n",
"\n",
"SRP\n",
"CBX1\n",
"ESET\n",
"JARID1B\n",
"PRC2\n",
"\n",
"\n",
"2. Uppercase text:\n",
"THIS IS JUST A SHORT EXAMPLE.\n",
"IT CONTAINS A FEW LINES. \n",
"MAYBE THIS IS A HEADER, AND BELOW ARE SOME PROTEINS OF INTEREST:\n",
"\n",
"SRP\n",
"CBX1\n",
"ESET\n",
"JARID1B\n",
"PRC2\n",
"\n",
"\n",
"3. Your protein is at position: \n",
"144\n",
"________________________________________________________________\n"
]
}
],
"source": [
"main()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This is a good time to state and/or remind that the order of execution is key.\n",
"What is the order of execution here?\n",
"\n",
"1. Define show_contents, but don't do anything with it\n",
"2. Define main, but don't do anything with it\n",
"3. Call and execute main.\n",
"4. Assign folder, document, and path\n",
"5. Open the input_file\n",
"6. Read the input file\n",
"7. Call and execute show_contents\n",
"8. ...\n",
"\n",
"There's a difference between 'main' and 'show_contents'...\n",
"What's the word 'text' doing in line 146?\n",
"\n",
"It's a parameter for the function.\n",
"Parameters are just the variables that a function need to run. \n",
"'type' says \"What variable do you want to know the name of?\"\n",
"'open' says \"What is the name of the file you want to open?\"\n",
"'show_contents' says \"What string do you want to output?\"\n",
"'main' doesn't need any parameters. \n",
"All of the variable that 'main' needs to run are inside of 'main'.\n",
"Although we have built show_contents to work for our document,\n",
"it can take other strings just like 'type' took different variables."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false
},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'show_output' is not defined",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m<ipython-input-6-f758c87db44f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0manother_string\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"This is just another sample string to show where we might look for PRC2.\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mshow_output\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0manother_string\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;31mNameError\u001b[0m: name 'show_output' is not defined"
]
}
],
"source": [
"another_string = \"This is just another sample string to show where we might look for PRC2.\"\n",
"show_contents(another_string)"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"________________________________________________________________\n",
"1. Originial text:\n",
"This doesn't have our protein. Is that a problem?\n",
"\n",
"2. Uppercase text:\n",
"THIS DOESN'T HAVE OUR PROTEIN. IS THAT A PROBLEM?\n",
"\n",
"3. Your protein is at position: \n",
"-1\n",
"________________________________________________________________\n"
]
}
],
"source": [
"bad_string = \"This doesn't have our protein. Is that a problem?\"\n",
"show_contents(bad_string)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"There's one more issue to address before we can sufficiently understand the 'open' line.\n",
"What's different about our use of 'main' & 'show_contents' compared to our use of 'open'?\n",
"\n",
"Using just the knowledge and terminology from this lecture,\n",
"you might say something like, \"a function call is being assigned to a variable\".\n",
"What's actually happening is that the 'open' function is returning a value.\n",
"This is done through the keyword 'return'.\n",
"Let's trying writing a function that returns a value to see how it works."
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"def read_file(path):\n",
" input_file = open(path)\n",
" text = input_file.read()\n",
" input_file.close()\n",
" return text"
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"def main():\n",
" folder = \"C:/Users/Jessime/Code/small_group/\"\n",
" document = \"ex_doc.txt\"\n",
" path = folder+document\n",
" text = read_file(path)\n",
" show_contents(text)"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"________________________________________________________________\n",
"1. Originial text:\n",
"This is just a short example.\n",
"It contains a few lines. \n",
"Maybe this is a header, and below are some proteins of interest:\n",
"\n",
"SRP\n",
"CBX1\n",
"ESET\n",
"JARID1B\n",
"PRC2\n",
"\n",
"\n",
"2. Uppercase text:\n",
"THIS IS JUST A SHORT EXAMPLE.\n",
"IT CONTAINS A FEW LINES. \n",
"MAYBE THIS IS A HEADER, AND BELOW ARE SOME PROTEINS OF INTEREST:\n",
"\n",
"SRP\n",
"CBX1\n",
"ESET\n",
"JARID1B\n",
"PRC2\n",
"\n",
"\n",
"3. Your protein is at position: \n",
"144\n",
"________________________________________________________________\n"
]
}
],
"source": [
"main()"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"Take a second to make sure you understand the exection flow after 'main()'. The end result of the script is exactly the same as the last two.There are multiple reasons why functions are useful, but one of them is that they provide levels of abstraction. Reading the main function immediately let's the user know \"We decide on a file, read it, and show its contents\". It's much easier to understand than our original script. \n",
"\n",
"So there are some of the details behind the 'open' line. Can we apply what we just learned to what we see in with 'input_file.read()'?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Introduction to Methods"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The short explaination of methods is simply: They are functions that are specific to a certain data type (or more accurately, \"class\", but that's for later). In this case, the function 'read' is specific to the 'file' type. The syntax for a method call is always the same as what is seen here:\n",
"\n",
"data.method()\n",
"\n",
"The 'method' will always operate on the 'data'. We can use what we just learned about functions to surmise that 'read' is a function, implemented somewhere else, that reads the contents of the file on which it is called, and returns those contents. It's as simple as that. \n",
"\n",
"If we go back and look at the 'show_contents' function, we'll see that the only two lines of code we haven't covered yet are methods that operate on our text variable, which is a string. Strings have a lot of methods. Let's check some of them out:"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"test = \"This is just a practice string. It's not very useful!!!\""
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"THIS IS JUST A PRACTICE STRING. IT'S NOT VERY USEFUL!!!\n",
"13\n"
]
}
],
"source": [
"print test.upper()\n",
"print test.find(\"a\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For comparison, here are the same methods that we just used."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n",
"this is just a practice string. it's not very useful!!!\n",
"This is just prctice string. It's not very useful!!!\n"
]
}
],
"source": [
"print test.count(\"a\") #Counts the number of times the letter 'a' occurs\n",
"print test.lower() #lowercase everything\n",
"print test.replace(\"a\", \"\") #Deletes the letter 'a'."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Notice that the method 'replace' takes two parameters. This is perfectly acceptable. It needs to know what characters you want to replace with what other characters. "
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This Is Just A Practice String. It'S Not Very Useful!!!\n",
"This is just a practice string. It's not very useful\n"
]
}
],
"source": [
"print test.title()\n",
"print test.strip(\"!\")"
]
}
],
"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.11"
},
"toc": {
"toc_cell": true,
"toc_number_sections": true,
"toc_threshold": 6,
"toc_window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 0
}
@aashishbn
Copy link

Nice !!!

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment