http://datacamp-community-prod.s3.amazonaws.com/21fdc814-3f08-4aa9-90fa-247eedefd655

This Jupyter Notebook cheat sheet will help you to find your way around the well-known Jupyter Notebook App, a subproject of Project Jupyter.

Jupyter Notebook Cheat Sheet

https://s3.amazonaws.com/assets.datacamp.com/blog_assets/Jupyter_Notebook_Cheat_Sheet.pdf

https://www.datacamp.com/community/podcast/harnessing-the-power-of-collaboration

In this episode of DataFramed, we speak with Brian Campbell, Engineering Manager at Lucid Software about managing data science projects effectively and harnessing the power of collaboration.

In this episode of DataFramed, we speak with Brian Campbell, Engineering Manager at Lucid Software about managing data science projects effectively and harnessing the power of collaboration.

Harnessing the Power of Collaboration

https://www.datacamp.com/community/blog/harnessing-the-power-of-collaboration

https://www.datacamp.com/community/podcast/project-jupyter-interactive-computing

Learn about data science, interactive computing, open source software, and Project Jupyter.

Learn about data science, interactive computing, open source software, and Project Jupyter.

Project Jupyter and Interactive Computing

https://www.datacamp.com/community/blog/project-jupyter-interactive-computing

https://www.datacamp.com/community/news/project-jupyter-and-interactive-computing-with-brian-granger-s5txnc3ibv

Project Jupyter and Interactive Computing (with Brian Granger)

https://www.datacamp.com/community/news/visualization-of-electric-vehicles-with-matplotlib-69biva1vwva

Electric vehicles are becoming more prevalent. They are without a doubt the future of the car industry. I used pandas to retrieve, clean and manipulate the data, and matplotlib for visualization. If you are interested in creating the same plot, I have shared the source code in my github.

Visualization of electric vehicles with matplotlib

https://www.datacamp.com/community/news/jupyterlab-is-ready-for-users-7att8sanvdv

Project Jupyter is proud to announce the beta release series of JupyterLab, the next-generation web-based interface for Project Jupyter.

JupyterLab is ready for users

https://www.datacamp.com/community/news/jupyter-notebook-tutorial-the-definitive-guide-hzrk3tjh1sj

This tutorial explains how to install, run, and use Jupyter Notebooks for data science, including tips, best practices, and examples.

Jupyter Notebook Tutorial: The Definitive Guide

https://www.datacamp.com/community/news/experts-favorite-data-science-techniques-d78u4elt3u

What are the most favorite techniques of the professional data scientists interviewed in DataFramed, a DataCamp podcast? Explore all 6 of them in this tutorial!

Experts' Favorite Data Science Techniques

<center><a target="_blank" href="https://www.datacamp.com/webinars/bridging-the-communications-gap-with-data-literacy"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/v1627651026/blog-bridging-the-communications-gap-with-data-literacy-1_oczfxa.png" /></a></center>
The real business value of data literacy comes from empowering members of an organization to understand and extract insights from data. When data literacy is infused into the company’s culture, it can act as a powerful tool to break down analytics siloes and enable scalable data storytelling throughout the organization.
During this webinar, Marc will explore some of the key components of building a data literate organization, and what subject matter experts need to know to start thinking “data literate”. Here’s a breakdown of what to expect:
<ul>
<li>How to visualize data: Nowadays, companies work with huge amounts of data and analysts can easily lose track of the signal in the noise. Hence, It is vital that you are selective about what to include in your visualization. Data visualization combines skills from art and science to express the right information, while making data insights easily accessible to non-technical team members. To construct clear and efficient data visualization plots, it takes time, patience, and the ability to ask the right questions. Before building your plots, you should always start by asking the right questions about your data, such as: “What is the purpose of this visualization?”.
</li>
<li>Understand data types and data flows: Knowing what data types you are dealing with is vital in order to select the right visualization method. Having a good understanding about the wide variety of data types can help you perform better exploratory data analysis (EDA) and building adequate data models.
</li>
<li>Extracting insights from data: Many organizations generate large amounts of raw data; however, they fail to effectively harness its business applications. Hence, building a culture where most team members are empowered to understand and differentiate data insights is crucial in today’s world. Understanding different data types and choosing the appropriate chart or visualization method greatly contributes to convey the message of your data insights. During this webinar Marc Wintjen will share different techniques that will empower your team to extract actionable insights from data.
</li>
</ul>
If you want to stay ahead of the competition, extracting actionable insights from your data is a necessity, not an option. Therefore, building a data literate culture that empowers your team to generate, capture, and analyse data will give your business a great competitive advantage over the rest of the market.
To learn more about how data culture can be adopted within your organization and empower your team to make better data-driven decisions <a target="_blank" href="https://www.datacamp.com/webinars/bridging-the-communications-gap-with-data-literacy">join our webinar with Marc Wintjen, Bloomberg’s Risk Analytics Architect.</a>

https://www.datacamp.com/community/blog/bridging-the-communications-gap-with-data-literacy

Marc Wintjen, Bloomberg’s Risk Analytics Architect and author of Practical Data Analysis using Jupyter Notebooks, will join us this 5th of August to discuss how the key principles to building data literacy in your organization can empower your team to make better and informed decisions.

Marc Wintjen, Bloomberg’s Risk Analytics Architect and author of Practical Data Analysis using Jupyter Notebooks, will join us to discuss how key principles to building data literacy in your organization can empower your team.

Bridging the Communications Gap with Data Literacy

<h2 id="what-is-a-jupyter-notebook-">What is a Jupyter Notebook?</h2>
&#39;Jupyter&#39; is an acronym meaning Julia, Python, and R. These programming languages were the original use case for Jupyter. Now though, Jupyter Notebook supports many other languages (Source: <a href="https://medium.com/@blessedmarcel1/how-to-install-jupyter-notebook-on-mac-using-homebrew-528c39fd530f">How to install Jupyter Notebook on Mac using Homebrew</a>).
The main components of the whole environment are, on the one hand, the notebooks themselves and the application. On the other hand, you also have a notebook kernel and a notebook dashboard.
&quot;&#39;notebook&#39; denotes documents that contain both code and rich text elements, such as figures, links, equations, etc. Because of the mix of code and text elements, these documents are the ideal place to bring together an analysis description and its results. They also can be executed to perform the data analysis in real-time&quot; —<a href="https://medium.com/@blessedmarcel1/how-to-install-jupyter-notebook-on-mac-using-homebrew-528c39fd530f">How to install Jupyter Notebook on Mac using Homebrew</a>.
Let&#39;s look at these components in more detail.
<h3 id="what-is-the-jupyter-notebook-app-">What is the Jupyter Notebook App?</h3>
As a server-client application, the Jupyter Notebook App allows you to edit and run your notebooks via a web browser. The application can be executed on a PC without Internet access, or it can be installed on a remote server, where you can access it through the Internet.
<h2 id="advantages-of-a-jupyter-notebook">Advantages of a Jupyter Notebook</h2>
<ul>
<li>Notebook has the ability to re-run individual code snippets, and it provides you the flexibility of modifying them before re-running.
</li>
<li>You can deploy a Jupyter Notebook on a remote server and access it from your local web browser.
</li>
<li>You can insert notes and documentation to your code in a Jupyter Notebook in various formats like markdown, latex, and HTML.
</li>
<li>Headings in a Jupyter Notebook are also supported, which is very useful when you want to provide heading &amp; sub-heading to signify various important parts of your codebase. It helps improve the readers&#39; experience.
</li>
<li>Use a Jupyter Notebook as cells.
</li>
<li>Ability to share a Jupyter Notebook in various formats like <code>.py</code>, <code>.html</code>, <code>.md</code>, <code>.pdf</code>, etc.
</li>
<li>For machine learning folks, Jupyter Notebook is very helpful since it allows for Data Visualization. Jupyter Notebook supports visualizations and enables you to render graphs and charts. These are generated from codes with the help of modules like Matplotlib, Plotly, or Bokeh.
</li>
</ul>
<h2 id="how-to-install-the-notebook-using-pip-">How to Install the Notebook Using <code>pip</code></h2>
If you don&#39;t want to install Anaconda, you just have to make sure that you have the latest version of <code>pip</code>. If you have installed Python, you will typically already have it.
What you do need to do is upgrade <code>pip</code> but before, that let&#39;s install and create a virtual environment:
<pre><code class="lang-python"># On OS X or Linux
pip3 install virtualenv
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465233/jup1_woihqi.png" alt="Installing Jupyter Notebook">
</figure>
</center>

Now let&#39;s create a virtual environment <code>jupyter</code> and activate it!
<pre><code class="lang-python">virtualenv jupyter
source jupyter/bin/activate
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465231/jup2_a5yndv.png" alt="Installing Jupyter Notebook">
</figure>
</center>

Let&#39;s upgrade <code>pip</code> now, but first, let&#39;s check the already installed <code>pip</code> version.
<pre><code class="lang-python">pip3 --version
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465230/jup3_nnffd7.png" alt="Installing Jupyter Notebook">
</figure>
</center>

From the above output, you can see that we have <code>pip</code> version <code>20.2.1</code>.
Let&#39;s upgrade that:
<pre><code class="lang-python"># On Windows
python -m pip install -U pip setuptools
# On OS X or Linux
pip3 install -U pip setuptools
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465231/jup4_qgtyl2.png" alt="Installing Jupyter Notebook">
</figure>
</center>

Once you have <code>pip</code>, you can just run the below command to install a Jupyter Notebook, which would take a while to install.
<pre><code class="lang-python">pip3 install jupyter
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465232/jup5_rgihme.png" alt="Installing Jupyter Notebook">
</figure>
</center>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465232/jup6_cztm0d.png" alt="Installing Jupyter Notebook">
</figure>
</center>

Great! So you are all set to run and start using Jupyter Notebook but before that, let&#39;s also look at how you can install jupyter using Anaconda.
<h2 id="how-to-install-jupyter-notebook-using-anaconda">How to Install Jupyter Notebook Using Anaconda</h2>
One of the requirements here is Python, Python 3.3, or greater since Python 2.7 has reached the end of its life (EOL) on January 1st, 2020. The general recommendation is that you use the Anaconda distribution to install both Python and the Jupyter Notebook.
Jupyter Notebook in Anaconda comes pre-installed, meaning that you do not have to install it explicitly. All you need to install is Anaconda, and Jupyter Notebook would already be present inside it.
Anaconda&#39;s advantage is that you have access to over 720 packages that can easily be installed with Anaconda&#39;s conda, a package, dependency, and environment manager. You can follow the instructions for the installation of Anaconda here for <a href="https://www.datacamp.com/community/tutorials/installing-anaconda-mac-os-x">Mac</a> or <a href="https://www.datacamp.com/community/tutorials/installing-anaconda-windows">Windows</a>.
Is something not clear? You can always read up on the Jupyter installation instructions <a href="https://jupyter.readthedocs.io/en/latest/install.html">here</a>.
If you need more information about installing packages in Python, you can go to <a href="https://packaging.python.org/installing/">this page</a>.
<h2 id="getting-started-with-jupyter-notebook">Getting Started With Jupyter Notebook</h2>
Now that you have learned all about what Jupyter Notebooks are, their benefits, and how to install them on your machines, let&#39;s put them to some practical use!
<h3 id="launching-jupyter-notebook">Launching Jupyter Notebook</h3>
To launch your Jupyter notebook, simply type the below command!
<pre><code class="lang-python">jupyter notebook
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465232/jup7_hsg0fi.png" alt="Installing Jupyter Notebook">
</figure>
</center>

Once you do this, the Jupyter notebook should open up the below tab for you inside your web browser:
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465231/jup9_rv1uc2.png" alt="Installing Jupyter Notebook">
</figure>
</center>

Note that the Jupyter Notebook will open using the below URL:
<a href="http://localhost:8888/tree">http://localhost:8888/tree</a>
However, the port number <code>8888</code> might change if a process is using it or a second Jupyter Notebook session runs in the background.
In some cases, the Jupyter Notebook might not open up on its own, in which case you can simply copy one of the URLs that are generated when you run the command <code>jupyter notebook</code>, which in our case is:
<a href="http://localhost:8889/?token=e41173caeda552cdcab1bcc775e2463ac510b8847f73604b">http://localhost:8889/?token=e41173caeda552cdcab1bcc775e2463ac510b8847f73604b</a>
Now, let&#39;s open a Python3 Notebook inside Jupyter by clicking the <code>New</code> tab and select <code>Python3</code>:
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465231/jup10_mthrq0.png" alt="Installing Jupyter Notebook">
</figure>
</center>

And finally, we have our very first Python3 Jupyter Notebook:
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465232/jup11_pfmhbo.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<h3 id="adding-heading-and-notes-in-jupyter-notebook">Adding Heading and Notes in Jupyter Notebook</h3>
In the drop-down menu shown below, you have four options:
<ul>
<li>Code – In the code cell, you write the Python code.</li>
</ul>
<ul>
<li>Markdown – In this cell type, you can add headings, notes, documentation, etc.</li>
</ul>
<ul>
<li>Raw NBConvert – This cell type can be used to render different code formats into HTML or LaTeX. This information is stored in the notebook metadata and converted appropriately.</li>
</ul>
Let&#39;s look at the <code>markdown</code> example for adding headings and bullet points:
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465232/jup12_gki9jz.png" alt="Installing Jupyter Notebook">
</figure>
</center>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465233/jup13_njmhvx.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<h3 id="sharing-a-jupyter-notebook">Sharing a Jupyter Notebook</h3>
This is one of the great and cool features of a Jupyter Notebook.
Go to the <code>Files</code> menu, and you’ll see a <code>Download As</code> option where you can download the Jupyter Notebook in almost nine different ways. The most commonly used is either a <code>.ipynb</code> or <code>.py</code> file:
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465232/jup14_v2gzvf.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<h3 id="installing-a-python-module-in-jupyter-notebook">Installing a Python Module in Jupyter Notebook</h3>
Installing a Python module inside Jupyter Notebook is as easy as installing it from the terminal. All you need to do is use an <code>!</code>(exclamation) mark at the start of the command, as shown below:
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465233/jup15_prcdrd.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<h3 id="writing-a-python-function-in-jupyter-notebook">Writing a Python Function in Jupyter Notebook</h3>
Let&#39;s write a Python function that generates random integers between 0 and 100 five times, and each time the size of the vector increments by one.
First, let&#39;s import <code>numpy</code>.
<pre><code class="lang-python">import numpy as np
</code></pre>
Next, the <a href="https://www.datacamp.com/community/tutorials/numpy-random"><code>random</code> function</a> which takes two inputs, <code>low</code> and <code>size</code> of the array, and finally returns the <code>num</code>.
<pre><code class="lang-python">def random(low, size):
 num = np.random.randint(low=low ,size=size)
 return num
</code></pre>
<pre><code class="lang-python">for i in range(5):
 print(random(100, i+1))
</code></pre>
<pre><code>[80]
[19 89]
[66 72 77]
[41 55 82 10]
[95 90 53 99 46]
</code></pre><h2 id="conclusion">Conclusion</h2>
In this Jupyter Notebook tutorial, you were introduced to its advantages. You further learned how to install Jupyter Notebook using <code>pip</code> and Anaconda. Finally, we covered a few practical use-cases like how to make headings, write python code, and how to share a Jupyter Notebook.
To learn more about Jupyter Notebook, please check out this complete comprehensive tutorial <a href="https://www.datacamp.com/community/tutorials/tutorial-jupyter-notebook#WhatIs">Jupyter Notebook Tutorial: The Definitive Guide</a>.

https://www.datacamp.com/community/tutorials/installing-jupyter-notebook

Follow download, setup, & install steps for Jupyter Notebook using Pip & Anaconda in this tutorial. Get up &running with Jupyter Notebook today!

How to Download & Setup Install Jupyter Notebook using Pip & Anaconda

Installing Jupyter Notebook

If you are just getting started in Python and would like to learn more, take DataCamp&#39;s <a href="https://www.datacamp.com/courses/intermediate-python">Intermediate Python</a> course.
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1585947048/doc1_mph0hj.png" style="width:100%">
 <figcaption><center><a href="https://pandas.pydata.org/pandas-docs/stable/index.html">Python&#39;s Pandas Library Documentation using Sphinx</a </center></figcaption>
</figure>

<h3 id="relevance-of-documenting-your-project">Relevance of Documenting your Project</h3>
Documentation is an essential part of any project you work on, irrespective of the programming language you use. A project having an application consisting of various API&#39;s up and running being used by many users but without documentation would be deemed incomplete. For a second, imagine yourself as a developer, how would you feel if you wanted to replicate a project or use some aspect of a project that does not have any documentation? I am sure you would have a hard time integrating it with your architecture.
Better documentation will make your project more successful because you know that when you share the project or the software with the world, you would like the world to use it, especially when it&#39;s an open-source project the goal would be even more. You would also want the community to contribute to your project and make it better.
The well-known author of Python programming language quotes that <code>Code is more often read than written.</code> This quote should highlight the importance documentation has on your code or project being implemented by others.
Imagine yourself as an employee of XYZ company, you are serving your notice period, and your manager would like you to transfer that project to your colleague. You might give him a KT (knowledge transfer), but what if your colleague fails to execute one of the codes from the project successfully? There could be several reasons as to why the code doesn&#39;t work, maybe the binaries your code runs on doesn&#39;t match with the binaries of the current OS.
<h4 id="what-exactly-is-a-documentation-">What exactly is a Documentation?</h4>
Documentation has several components attached to it. It needs to be well-structured around these components and adhere to those components to be considered proper documentation.
On an abstract level, the components are:
<ul>
<li>Making sure the codebase of your project is well commented.
</li>
<li>It follows Python&#39;s PEP-8 coding standards.
</li>
<li>Concrete tutorials about how the project was built, especially when its an open-source project developed for a learning-oriented purpose.
</li>
<li>A guide on how to install the necessary packages, modules used to build the software, a technical specification sheet if the project also includes any hardware. For example, how to install anaconda, TensorFlow, Keras, etc.
</li>
<li>Several discussions on the project&#39;s progress at each time step that could have led to the successful implementation of the software.
</li>
<li>Reference material that provides a technical description of the technology stack used during the development phase.
</li>
<li>The architectural design of the project or the software solution.
</li>
</ul>
These points are just some of the components that could exist in a well-structured and a perfect looking document. It is important to keep all these components distinct, which would also make it easier to maintain the documentation in the future.
An example of comprehensive documentation that has most of the components we discussed would be similar to the one as shown below:
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1585947048/doc2_hnrhge.png" style="width:200%">
 <figcaption><center><a href="https://docs.djangoproject.com/en/3.0/">Django&#39;s Documentation</a </center></figcaption>
</figure>

A lot of people often get confused between <code>commenting</code> &amp; <code>documenting</code> and consider them similar. Commenting is used to describe your code to the user, maintainer, and even for your self as a future reference. Commenting only works at the code-level and can be categorized as a subset of documentation. Comments help guide the reader to:
<ul>
<li>understand your code,</li>
<li>make it self-explanatory, and</li>
<li>understand its purpose and design.</li>
</ul>
It is important to remember that since Python follows the PEP-8 coding standards, even comments have to adhere to those standards. The official Python documentation states that flowing long blocks of text with fewer structural restrictions (docstrings or comments), the line length should be limited to 72 characters.
To check whether your code adheres to the PEP-8 standards, you can use the <code>pylint</code> module of Python. This module can be used to modify the character limit for comments and all other lines of code.
Let&#39;s see a couple of examples.
<ul>
<li>Importing module description</li>
</ul>
<pre><code class="lang-python">import tensorflow as tf
#imports tensorflow as tf. Tensorflow is an n-dimensional matrix.
#just like a 1-D vector, 2-D array, 3-D array etc.
</code></pre>
<ul>
<li>Variable definition description</li>
</ul>
<pre><code class="lang-python">n_classes = 10 # MNIST total classes (0-9 digits)
</code></pre>
For a more in-depth understanding of commenting and its do&#39;s &amp; don&#39;ts, check out <a href="https://blog.codinghorror.com/when-good-comments-go-bad/">this</a> helpful post.
Let&#39;s now learn how docstrings can help in documenting your project codebase.
<h3 id="docstrings-for-documenting-python-code">Docstrings for Documenting Python Code</h3>
Python Docstring is the documentation string that is string literal, and it occurs in the class, module, function, or method definition, and is written as a first statement. Docstrings are accessible from the doc attribute <code>(__doc__)</code> for any of the Python objects, and also with the built-in <code>help()</code> function can come in handy.
Also, Docstrings are great for understanding the functionality of the larger part of the code, i.e., the general purpose of any class, module, or function. In contrast, the comments are used for code, statement, and expressions, which tend to be small. They are a descriptive text written by a programmer mainly for themselves to know what the line of code or expression does and also for the developer who wishes to contribute to that project. It is an essential part that documenting your code is going to serve well enough for writing clean code and well-written programs. Though already mentioned, there are no standards and rules for doing so.
There are two forms of writing a Docstring: one-line Docstrings and multi-line Docstrings. These are the documentation that is used by Data Scientists/programmers in their projects.
<ul>
<li>The <code>one-line</code> Docstrings are the Docstrings, which fits all in one line. You can use one of the quotes, i.e., triple single or triple-double quotes, opening quotes, and closing quotes need to be the same. In the one-line Docstrings, closing quotes are in the same line as with the opening quotes. Also, the standard convention is to use the triple-double quotes.</li>
</ul>
<pre><code class="lang-python">def square(a):
 &#39;&#39;&#39;Returned argument a is squared.&#39;&#39;&#39;
 return a**a

print (square.__doc__)


help(square)
</code></pre>
<pre><code>Returned argument a is squared.
Help on function square in module __main__:

square(a)
 Returned argument a is squared.
</code></pre><ul>
<li><code>Multi-line</code> Docstrings also contains the same string literals line as in One-line Docstrings, but it is followed by a single blank along with the descriptive text.</li>
</ul>
<pre><code class="lang-python">def some_function(argument1):
 &quot;&quot;&quot;Summary or Description of the Function

 Parameters:
 argument1 (int): Description of arg1

 Returns:
 int:Returning value

 &quot;&quot;&quot;

 return argument1

print(some_function.__doc__)
</code></pre>
<pre><code>Summary or Description of the Function

 Parameters:
 argument1 (int): Description of arg1

 Returns:
 int:Returning value
</code></pre><figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1585947048/doc3_hajmrg.png" style="width:200%">
 <figcaption><center><a href="https://www.datacamp.com/community/tutorials/docstrings-python">Renowned Docstring Formats</a </center></figcaption>
</figure>

From the above table, let&#39;s pick <code>Pydoc</code> as one of the docstring formats and explore it a bit.
As you learned that docstrings are accessible through the built-in Python <code>__doc__</code> attribute and the <code>help()</code> function. You could also make use of the built-in module known as <code>Pydoc</code>, which is very different in terms of the features &amp; functionalities it possesses when compared to the doc attribute and the help function.
Pydoc is a tool that would come handy when you want to share the code with your colleagues or make it open-source, in which case you would be targeting a much wider audience. It could generate web pages from your Python documentation and can also launch a web server.
Let&#39;s see how it works.
The easiest and convenient way to run the Pydoc module is to run it as a script. To run it inside a jupyter lab cell, you would make use of the exclamation mark (!) character.
<pre><code class="lang-python">!python -m pydoc
</code></pre>
<pre><code>pydoc - the Python documentation tool

pydoc &lt;name&gt; ...
 Show text documentation on something. &lt;name&gt; may be the name of a
 Python keyword, topic, function, module, or package, or a dotted
 reference to a class or function within a module or module in a
 package. If &lt;name&gt; contains a &#39;\&#39;, it is used as the path to a
 Python source file to document. If name is &#39;keywords&#39;, &#39;topics&#39;,
 or &#39;modules&#39;, a listing of these things is displayed.

pydoc -k &lt;keyword&gt;
 Search for a keyword in the synopsis lines of all available modules.

pydoc -n &lt;hostname&gt;
 Start an HTTP server with the given hostname (default: localhost).

pydoc -p &lt;port&gt;
 Start an HTTP server on the given port on the local machine. Port
 number 0 can be used to get an arbitrary unused port.

pydoc -b
 Start an HTTP server on an arbitrary unused port and open a Web browser
 to interactively browse documentation. This option can be used in
 combination with -n and/or -p.

pydoc -w &lt;name&gt; ...
 Write out the HTML documentation for a module to a file in the current
 directory. If &lt;name&gt; contains a &#39;\&#39;, it is treated as a filename; if
 it names a directory, documentation is written for all the contents.
</code></pre>If you look at the above output, the very first use of Pydoc is to show text documentation on a function, module, class, etc. so let&#39;s see how you can leverage that better than the help function.
<pre><code class="lang-python">!python -m pydoc glob
</code></pre>
<pre><code>Help on module glob:

NAME
 glob - Filename globbing utility.

MODULE REFERENCE
 https://docs.python.org/3.7/library/glob

 The following documentation is automatically generated from the Python
 source files. It may be incomplete, incorrect or include features that
 are considered implementation detail and may vary between Python
 implementations. When in doubt, consult the module reference at the
 location listed above.

FUNCTIONS
 escape(pathname)
 Escape all special characters.

 glob(pathname, *, recursive=False)
 Return a list of paths matching a pathname pattern.

 The pattern may contain simple shell-style wildcards a la
 fnmatch. However, unlike fnmatch, filenames starting with a
 dot are special cases that are not matched by &#39;*&#39; and &#39;?&#39;
 patterns.

 If recursive is true, the pattern &#39;**&#39; will match any files and
 zero or more directories and subdirectories.

 iglob(pathname, *, recursive=False)
 Return an iterator which yields the paths matching a pathname pattern.

 The pattern may contain simple shell-style wildcards a la
 fnmatch. However, unlike fnmatch, filenames starting with a
 dot are special cases that are not matched by &#39;*&#39; and &#39;?&#39;
 patterns.

 If recursive is true, the pattern &#39;**&#39; will match any files and
 zero or more directories and subdirectories.

DATA
 __all__ = [&#39;glob&#39;, &#39;iglob&#39;, &#39;escape&#39;]

FILE
 c:\users\hda3kor\.conda\envs\test\lib\glob.py
</code></pre>Now, let&#39;s extract the <code>glob</code> documentation using the help function.
<pre><code class="lang-python">help(glob)
</code></pre>
<pre><code>---------------------------------------------------------------------------

NameError Traceback (most recent call last)

&lt;ipython-input-13-6f504109e3a2&gt; in &lt;module&gt;
----&gt; 1 help(glob)


NameError: name &#39;glob&#39; is not defined
</code></pre>Well, as you can see, it throws a name error as glob is not defined. So for you to use the help function for extracting the documentation, you need first to import that module, which is not the case in Pydoc.
Let&#39;s explore the most interesting feature of the Pydoc module, i.e., running Pydoc as a web service.
To do this, you would simply run the Pydoc as a script but with a <code>-b</code> argument which will start an HTTP server on an arbitrary unused port and open a Web browser to browse documentation interactively. This is helpful, especially when you have various other services running on your system, and you do not remember which port would be in an idle state.
<pre><code class="lang-python">!python -m pydoc -b
</code></pre>
<pre><code>^C
</code></pre>The moment you run the above cell, a new window will open on an arbitrary port number, and the web browser will look similar to the one shown below.
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1585947048/doc4_tg8rmb.png" style="width:200%">
</figure>

Let&#39;s look at the documentation of the <code>h5py</code> module, which is a file format used to store weights of neural network architecture.
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1585947048/doc5_zgficw.png" style="width:200%">
</figure>

<h4 id="essentials-while-documenting-python-projects">Essentials while Documenting Python Projects</h4>
Irrespective of the goal, vision, and project purpose, the documentation of every project remains more or less the same. The project could fall under the following categories:
<ul>
<li>Private ( personal ) Project: Could be for portfolio building or working as a freelancer maintaining a GitHub repository.
</li>
<li>Collaborative ( team) Projects: Could be a project being run at your organization or working on a Kaggle competition.
</li>
<li>Open-source Projects: Open Source projects are mainly focused on being shared with a broad audience. It expects collaboration, contributions, and maintainability of the codebase and documentation in a longer run.
</li>
</ul>
Even though the above three categories of projects have different visions, the documentation template could be shared across all kinds of projects.
Let&#39;s say you are working on an open-source project and are required to create a GitHub repository for it which should have detailed documentation updated regularly, following are the essential points you need to keep in mind:
<ul>
<li>Requirements file: A lot of time, authors tend to forget this, but the requirements file is very important. It helps the users to reproduce your code quickly. It is usually a text file that contains all the packages, modules along with their respective versions that were used in the project. Requirements can even be mentioned in the Readme file, but having it separately is always better since the user can just run that file with a <code>pip</code> command, and all the dependencies are then installed on their respective system.
</li>
<li>Readme: Readme file is usually a markdown file format, which also serves as the backbone for many projects. A summary of the project, its features, and its purpose with a nice logo. It shall include instructions for installing or operating the project. Additionally, add any significant changes since the previous version. Testing scripts or like a quick tour on running their code successfully within the Readme gives more confidence to the user to pursue your project. It could also highlight the potential problems the users could face.
</li>
<li>How to Collaborate: It is important, especially when you are working on open-source projects. This should include how new collaborators could contribute to the project. This includes developing new features, fixing known bugs, adding documentation, adding new tests, or reporting issues. The collaborators could even release a v2.0 of the same project and take the project to greater heights.
</li>
<li>License: A plaintext file that describes the license your project is using. Especially crucial for open-source projects, licenses like Boost, Apache, MIT, etc. This informs the user whether the project is free to be used commercially or up to what extent.
</li>
<li>Tasks assignment: If you are working on a shared project like Kaggle, you could define the tasks each member is assigned, and the progress level of the task. This helps keep track of the overall progress made in the project.
</li>
<li>Framework Re-usability: This plays a vital role in a shared project like Kaggle wherein your teammates could reuse what you might have built, which could save a lot of the time. For example, data preprocessing pipeline, data cross-validation script, etc.
</li>
</ul>
A highly recommended documentation that is very well structured and could potentially be a perfect example of how an open-source project shall look like then do check out <a href="https://github.com/huggingface/transformers">huggingface</a> transformers GitHub repository.
<h2 id="conclusion">Conclusion</h2>
Congratulations on finishing the tutorial.
One good exercise for you all would be to explore the Pydoc module a bit more and other Python docstring formats like Epydoc and Google docstrings and find out how they differ from each other.
Please feel free to ask any questions related to this tutorial in the comments section below.
References:
<ul>
<li><a href="https://www.datacamp.com/community/tutorials/docstrings-python">Docstrings in Python</a></li>
</ul>
If you are just getting started in Python and would like to learn more, take DataCamp&#39;s <a href="https://www.datacamp.com/courses/intermediate-python">Intermediate Python</a> course.

https://www.datacamp.com/community/tutorials/documenting-python-code

Learn why there is a need for documenting code and best practices to do it. Further, learn to leverage the potential of the Pydoc module for documenting purposes.

Find the best practices for documenting Python code. Follow our guide and see how to use the Pydoc module & leverage Docstrings for your documentation today!

community

datacamp

jupyter

News (13)

Project Jupyter and Interactive Computing (with Brian Granger)

Jupyter Notebook Tutorial: The Definitive Guide

Project Jupyter and Interactive Computing (with Brian Granger)

Tutorials (9)

Installing Jupyter Notebook

How to Document Python Code

Cheat Sheets (1)

Jupyter Notebook Cheat Sheet

Open Courses (0)

Podcast (2)

Harnessing the Power of Collaboration (with Brian Campbell)

Blog Posts (5)

Harnessing the Power of Collaboration

Tech Thoughts (0)