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.
<h1 id="conclusion">Conclusion</h1>
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.

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.

(Tutorial) How to Document Python Code

How to Document Python Code

<h2 id="variables">Variables</h2>
Variables are the identifier or the named space in the memory, which are stored and can be referenced and manipulated later in the program. R is a Dynamically Typed and Interpreted language where Type Checking of the variable and other objects is done at the run time. It also means that the Interpreter of R doesn&#39;t force the programmer to explicitly declare the &#39;data-type&#39; of the variable before its usage.
<h2 id="rule-variable-in-r">Rule Variable in R</h2>
<ol>
<li>The variable name must start with letter and can contain number,letter,underscore(&#39;&#39;) and period(&#39;.&#39;).</li>
 Example: variableName1,new.variable, 
 <ul>
<li>Underscore(&#39;&#39;) at the beginning of the variable name are not allowed.</li>
 Example: &#39;_my_var&#39; is not a valid variable name.
<li>Period(&#39;.&#39;) at the beginning of the variable name are allowed but should not be followed by a number. It is preferable in R to use &#39;.&#39; which helps to separate the different words for the identifier.</li>
 Example: &#39;.myvar&#39; is a valid variable name. However, &#39;.1myvar&#39; is not a valid variable name because the period followed by a number is not valid.

</ul>
<li>Reserved words or keywords are not allowed to be defined as a variable name.</li>
<li>Special characters such as &#39;#&#39;, &#39;&amp;&#39;, etc., along with White space (tabs, space) are not allowed in a variable name.</li></ol>

<h2 id="variable-assignment">Variable Assignment</h2>
Variables in R can be assigned in one of three ways. 
<ol>
<li>Assignment Operator: &quot;=&quot; used to assign the value.The following example contains 20 as value which is stored in the variable &#39;first.variable&#39;
Example: <code>first.variable = 20</code> 
</li>
<li>&#39;&lt;-&#39; Operator: The following example contains the New Program as the character which gets assigned to &#39;second.variable&#39;. 
Example: <code>second.variable &lt;- &quot;New Program&quot;</code> 
</li>
<li>&#39;-&gt;&#39; Operator: The following example contains 565 as the integer which gets assigned to &#39;third.variable&#39;. 
Example: <code>565 -&gt; third.variable</code></li>
</ol>
<h2 id="variable-type">Variable Type</h2>
The type of variable in R can be determined by class(),typeof() and mode() 
<ol>
<li>&#39;class()&#39;- will give the high-level type of an object, which is to say from the perspective of Object-Oriented Programming in R.Depending upon whether it is a vector or any other data structure, the return type will be different.
<ul>

<li>If the type of object is the vector, then one of the following data types is chosen.
<ul>
 <li>Integer</li>
 <li>Numeric</li>
 <li>Character</li>
 <li>Logical</li>
</ul>
For example, the integer type and numeric type will be returned below. 
 <code>my.var1 = 8L</code> 
 Returns:&#39;integer&#39; 
<code>my.var2 = 8.5</code> 
Returns:&#39;numeric&#39; </li> 
<li>However, with the objects like matrix(),data.frame(),list() and array() the respective type is returned.
 For example, the list type will be returned as &quot;list&quot; below. 
 <code>my.var3 = list(6,9,5)</code> 
 Returns:&#39;list&#39; 
</li>



</li>
</ol>
<ol>
<li>typeof()- The return values are low-level, which matches the internal type of object in R.It is mostly used by R programmer to determine the type of an object. 
For Example, some of the internal types of objects in R are shown below: 
<code>typeof(8+6i)</code> 
Returns: complex 
<code>typeof(factor(c(4,5,6)))</code> 
Returns: integer</li>
</ol>
You can explore the <a href="https://renenyffenegger.ch/notes/development/languages/R/functions/typeof">Object internal type with typeof()</a> to find the different internal type of an object. 
3.mode()- It also returns the values which are the same and closely related to &#39;typeof().&#39; However, there are some differences between &#39;typeof()&#39; and mode() on the following types.
<ul>
 <li>type &quot;symbol&quot; in typeof() is &quot;name&quot; in mode()</li>
 For Example: <code>typeof(as.name(&#39;foo&#39;))</code>Returns &#39;symbol&#39; whereas <code>mode(as.name(&#39;foo&#39;))</code> Returns &#39;name&#39;. 
 <li>type &quot;language&quot; in typeof() is returned as &quot;(&quot; or &quot;call&quot; in mode()</li>
 For Example: <code>typeof(y~x)</code>Returns &#39;language&#39; whereas <code>mode(45L)</code> Returns &#39;call&#39;. 
 <li>type &quot;integer&quot; and &quot;double&quot; in typeof() is returned as &quot;numeric&quot; in mode()</li>
 For Example: <code>typeof(45L)</code>Returns &#39;integer&#39; whereas <code>mode(45L)</code> Returns &#39;numeric&#39;. 
 <li>type &quot;special&quot; and &quot;builtin&quot; in typeof() is returned as &quot;function&quot; in mode()</li>
 For Example: <code>typeof(return)</code>Returns &#39;special&#39; whereas <code>mode(45L)</code> Returns &#39;function&#39;. </ul>





<h2 id="removing-variable">Removing Variable</h2>
The variable in R can easily be removed or deleted by using &#39;rm()&#39;. 
For example, the output of the code below is 8.
<pre><code>my.var = 8
cat(my.var)
</code></pre>The variable is removed by using &#39;rm(my.var)&#39;.
<pre><code>rm(my.var)
</code></pre>You can check whether the variable is removed or not through the help of &#39;cat(my.var)&#39;
<pre><code>cat(my.var)
</code></pre>The above code will result in the following error: 
Error in cat(my.var): object &#39;my.var&#39; not found
<h2 id="congratulations">Congratulations</h2>
Congratulations, you have made it to the end of this tutorial!
In this tutorial, you have covered R&#39;s variables, rules for defining variables, different types of assignment of the variable along with different kinds of checking the variable types, and removal of the variable.
If you would like to learn more about R, take DataCamp&#39;s <a href = "https://www.datacamp.com/learn/r-programming/">Introduction to R course.</a>

https://www.datacamp.com/community/tutorials/variables-in-r

In this tutorial, you'll learn all about R variables including how to define variables, remove variables, and much more.

(Tutorial) Definitive Guide: Variables in R

Definitive Guide: Variables in R

If you are just getting started in Python and would like to learn more, take DataCamp&#39;s <a href="https://learn.datacamp.com/courses/introduction-to-data-science-in-python">Introduction to Data Science in Python</a> course.
A global interpreter lock (GIL) is a mechanism to apply a global lock on an interpreter. It is used in computer-language interpreters to synchronize and manage the execution of threads so that only one native thread (scheduled by the operating system) can execute at a time.
In a scenario where you have multiple threads, what can happen is that both the thread might try to acquire the memory at the same time, and as a result of which they would overwrite the data in the memory. Hence, arises a need to have a mechanism that could help prevent this phenomenon. 
Some popular interpreters that have GIL are CPython and Ruby MRI. As most of you would know that Python is an interpreted language, it has various distributions like CPython, Jython, IronPython. Out of these, GIL is supported only in CPython, and it is also the most widely used implementation of Python. CPython has been developed in both C and Python language primarily to support and work with applications that have a lot of C language underneath the hood.
Even if your processor has multiple cores, a global interpreter will allow only one thread to be executed at a time. This is because, when a thread starts running, it acquires the global interpreter lock. When it waits for any I/O operation ( reading/writing data from/to disk ) or a CPU bound operation ( vector/matrix multiplication ), it releases the lock so that other threads of that process can run. Hence, it prevents you from running the other threads at the same time.
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1585364509/gil_g47wzi.png" />
</figure>
</center> 

Let&#39;s take a moment and understand the above diagram. As you can see, there is a <code>factorial</code> function and two threads 1 and 2, thread 1 is in the locked state while thread 2 is in a wait state. This means that only one of the threads is able to access the function. Now, let&#39;s assume that the <code>factorial</code> function takes 2 seconds to complete. Then, in an ideal case, both the threads should be able to finish the execution in 2 seconds. However, this is not the case in Python, both the threads will run serially and not parallel to each other.
The threads 1 and 2 calling the <code>factorial</code> function may take twice as much time as a single thread calling the function twice. This also tells you that the memory manager governed by the interpreter is not <code>thread-safe</code>, which means that multiple threads fail to access the same shared data simultaneously.
Hence, GIL (Source: <a href="https://www.dabeaz.com/python/UnderstandingGIL.pdf">Understanding the Python GIL</a>):
<ul>
<li>Limits the threading operation.
</li>
<li>Parallel execution is restricted.
</li>
<li>The GIL ensures that only one thread runs in the interpreter at once.
</li>
<li>It helps in simplifying various low-level details like memory management.
</li>
</ul>
<h4 id="with-gil-cooperative-computing-or-coordinated-multitasking-is-achieved-instead-of-parallel-computing-">With GIL cooperative computing or coordinated multitasking is achieved instead of parallel computing.</h4>
<a id='table'></a>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1585364510/gil2_kgyuui.png" style="width:100%">
 <figcaption><center><a href="https://speakerdeck.com/dabeaz/understanding-the-python-gil?slide=10">Source</a </center></figcaption>
</figure>


As it can be observed from the above diagram, there are three threads initially the thread 1 is running and it has acquired the GIL, and when an I/O operation like a read, write, etc. is done, thread 1 releases the GIL and it is then acquired by thread 2. This cycle keeps on going, and GIL keeps changing threads alternatively till the threads have completed the execution of the program. Remember that if any of the threads that do not have the lock and have not completed the execution, they will then be in a waiting state.
<a id='gil1'></a>
<h5 id="gil-in-python2-vs-python3">GIL in Python2 vs. Python3</h5>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1585364509/gil3_asst6i.png" />
</figure>
</center>

Global Interpreter Lock in Python 2.7 works differently when compared to Python3. In a pure CPU-bound operation, the thread continues to run since there is no I/O operation in which case the other threads will be in an idle or a wait state, which is not what you would want. To solve this issue, Python2 has terminology known as <code>ticks</code>. The global interpreter lock performs a check to monitor the state of thread-like wait state, I/O operation, or whether it is being run. However, GIL does not keep monitoring the threads at every instance or time, rather it uses the concept of <code>ticks</code>, and it checks the threads at every 100 ticks.
A tick is a byte-code instruction, and when the 100 byte-code instructions are completed, the GIL checks whether the threads are running or in a waiting state. It is important to remember that a tick is not related to time since it is a byte-code instruction. Each tick might take a longer or shorter time to run compared to the other.
<a id='table'></a>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1585364510/gil4_id7go7.png" style="width:100%">
 <figcaption><center><a href="https://speakerdeck.com/dabeaz/understanding-the-python-gil?slide=12">Source</a </center></figcaption>
</figure>



This periodic check of monitory the threads after every 100 ticks is essential, especially in CPU bound operations since they do not have any I/O operations. Note that you can modify the tick counter using the built-in <code>sys</code> module of Python.
<a id='table'></a>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1585364510/gil5_qju0lo.png" style="width:100%">
 <figcaption><center><a href="https://speakerdeck.com/dabeaz/understanding-the-python-gil?slide=11">Source</a </center></figcaption>
</figure>

Let&#39;s discuss some of the demerits of the above approach:
Now, if you look at <a href="#gil1">this</a> diagram, you may notice that the threads are not running parallel to each other but in a serial order, also known as cooperative computing governed by the global interpreter lock. Also, the threads have to wait for longer durations. For example, the thread T3 had to wait for both the threads T1 &amp; T2 to release the GIL. Hence, the threads starve for the lock and the compute.
Another demerit is that there is a battle between the threads as to which thread will acquire the GIL. Initially, it might be the case that based on the priority T1 would have got the GIL, then T2, and so on. However, when T3 releases GIL, it will send a notification to all other threads, in which case all other threads will keep fighting to acquire the GIL. Having said that, you could potentially overcome this by setting the priorities of each thread.
<h4 id="in-python3-you-have-fixed-time-allocated-for-each-thread-i-e-5ms-of-execution-time-this-prevents-the-threads-from-starving-for-resources-since-the-waiting-time-is-equal-for-all-the-threads-the-threads-will-wait-to-see-if-the-gil-gets-released-by-thread-1-on-purpose-because-of-i-o-or-sleep-operation-if-not-it-will-force-it-to-release-after-5ms-hence-there-will-not-be-any-starvation-of-cpu-time-since-every-thread-will-get-an-equal-amount-of-time-and-this-will-eliminate-the-challenge-of-acquiring-the-gil-">In Python3, you have fixed-time allocated for each thread, i.e., 5ms of execution time. This prevents the threads from starving for resources since the waiting time is equal for all the threads. The threads will wait to see if the GIL gets released by Thread 1 on purpose because of I/O or sleep operation. If not, it will force it to release after 5ms. Hence, there will not be any starvation of CPU time since every thread will get an equal amount of time, and this will eliminate the challenge of acquiring the GIL.</h4>
<a id='table'></a>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1585364510/gil8_kcolyd.png" style="width:100%">
 <figcaption><center></center></figcaption>
</figure>

However, it is important to note that the new implementation of GIL gives more priority to CPU-bound jobs as compared to the I/O operations. In a case where a thread has released the GIL, and two threads are waiting, GIL will be acquired by the thread which has a requirement of running a CPU-bound job as compared to the other thread.
<h1 id="conclusion">Conclusion</h1>
Congratulations on finishing the tutorial.
This tutorial covered an advanced topic, and the purpose was to give you all a theoretical overview of how exactly GIL works in Python. Since this tutorial did not cover any coding aspects of GIL and threads, one good exercise for you all would be to experiment on your own by creating multiple threads and a method that performs an I/O intensive task and finally analyzes how the GIL is switched between each thread.
Please feel free to ask any questions related to this tutorial in the comments section below.
References:
<ul>
<li><a href="https://www.dabeaz.com/python/UnderstandingGIL.pdf">Understanding the Python GIL</a></li>
</ul>
If you are just getting started in Python and would like to learn more, take DataCamp&#39;s <a href="https://learn.datacamp.com/courses/introduction-to-data-science-in-python">Introduction to Data Science in Python</a> course.

https://www.datacamp.com/community/tutorials/python-global-interpreter-lock

Learn what Global Interpreter Lock is, how it works, and why you should use it.

(Tutorial) Python Global Interpreter Lock

Python Global Interpreter Lock

If you are just getting started in Python and would like to learn more, take DataCamp&#39;s <a href="https://learn.datacamp.com/courses/introduction-to-data-science-in-python">Introduction to Data Science in Python</a> course.
<a id='log1'></a>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1584715062/logging1_sjhzzn.png" style="width:100%">
 <figcaption><center>Levels of Logging</center></figcaption>
</figure>

In general, logging is a way of keeping a log generated from a computer program. A log file usually has a set of records of events that occur in your code ( for example, a python code ) or an operating system. These events or messages are written to a log file, a message, or an event can also be a communication between different users.
It usually depends on the developers on how they would like to generate logs. Maybe they would like to log every operation of an application they developed, log only when an error occurs, or monitor essential operations done by a user and log them. An essential operation could be to check the application or the server was accessed by which end-user or IP address, and in case it was an unsuccessful attempt, the developer then could seek help from the logs and provide better insights than a mere stack trace.
A nice example would be when you try to do an installation on Linux as a sudo user when you are not a sudo user. You see a message &quot;Xyz is not in the sudoers file. This incident will be reported&quot;, which is written in a log file.
The good news is that Python comes with a built-in logging module, and you can use it off the shelf without any installation.
<h4 id="how-logging-is-different-from-a-print-function-">How logging is different from a Print Function?</h4>
Logging is similar in spirit to a <code>Print Function</code>. However, a Print function lacks a lot of information that might be useful to a developer. Logging, on the other hand, can log the timestamps and line number at which the error occurred. It can log errors or any information to files, sockets, etc., and it offers you five types of severity based on which you can differentiate your logging.
Five Levels of Logging as shown <a href="#log1">here</a>, are:
<ul>
<li>Debug (10): Useful for diagnosing issues in the code.
</li>
<li>Info (20): It can act as an acknowledgment that there are no bugs in the code. One good use-case of Info level logging is the progress of training a machine learning model.
</li>
<li>Warning (30): Indicative of a problem that could occur in the future. For example, a warning of a module that might be discontinued in the future or low-ram warning.
</li>
<li>Error (40): A serious bug in the code, could be a syntax error, out of memory error, exceptions.
</li>
<li>Critical (50): An error due to which the program might stop functioning or might exit abruptly.
</li>
</ul>
Enough of theory, right?
Let&#39;s now understand how you can implement logging in a Python code.
But before that, let&#39;s see the logging attribute table, you would be using some of the below logging attributes in today&#39;s tutorial.
<a id='table'></a>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1584715063/logging5_ugwysb.png" style="width:100%">
 <figcaption><center><a href="https://docs.python.org/3/library/logging.html">Logging Attributes</a </center></figcaption>
</figure>


<pre><code class="lang-python">import logging
</code></pre>
Now you will call the <code>basicConfig()</code> method, which helps you in creating a basic configuration for the logging system to work smoothly. 
 
It allows you to set the following parameters:
<ul>
<li>the severity of the logging: the five levels of logging.</li>
<li>log the events into a file.</li>
<li>log only the current logs by overwriting the old ones using the filemode.</li>
<li>file format in which logs are stored. </li>
</ul>
Remember that the <code>basicConfig()</code> method is optional, and you might want to skip it.
<pre><code class="lang-python">logging.basicConfig()
</code></pre>
Let&#39;s now build the five levels of severity.
<pre><code class="lang-python">logging.debug(&quot;A Debug Logging Message&quot;)
</code></pre>
<pre><code class="lang-python">logging.info(&quot;A Info Logging Message&quot;)
</code></pre>
<pre><code class="lang-python">logging.warning(&quot;A Warning Logging Message&quot;)
</code></pre>
<pre><code>WARNING:root:A Warning Logging Message
</code></pre><pre><code class="lang-python">logging.error(&quot;An Error Logging Message&quot;)
</code></pre>
<pre><code>ERROR:root:An Error Logging Message
</code></pre><pre><code class="lang-python">logging.critical(&quot;A Critical Logging Message&quot;)
</code></pre>
<pre><code>CRITICAL:root:A Critical Logging Message
</code></pre>As you can observe from the above outputs, only the ones which have severity level greater than 20 were successfully logged since that is the default configuration of logging in Python.
However, as discussed above, you can modify the severity levels using the <code>basicConfig()</code> method.
Here you would change the severity level to 20, which means logging levels having severity greater than 10 will be logged.
Note: Kindly restart the kernel before running the below cells to see the correct output.
<pre><code class="lang-python">import logging
</code></pre>
<pre><code class="lang-python">logging.basicConfig(level=logging.INFO)
</code></pre>
<pre><code class="lang-python">logging.debug(&quot;A Debug Logging Message&quot;)
</code></pre>
<pre><code class="lang-python">logging.info(&quot;A Info Logging Message&quot;)
</code></pre>
<pre><code>INFO:root:A Info Logging Message
</code></pre><pre><code class="lang-python">logging.warning(&quot;A Warning Logging Message&quot;)
</code></pre>
<pre><code>WARNING:root:A Warning Logging Message
</code></pre><pre><code class="lang-python">logging.error(&quot;An Error Logging Message&quot;)
</code></pre>
<pre><code>ERROR:root:An Error Logging Message
</code></pre><pre><code class="lang-python">logging.critical(&quot;A Critical Logging Message&quot;)
</code></pre>
<pre><code>CRITICAL:root:A Critical Logging Message
</code></pre>Let&#39;s now log the above outputs in a log file. To achieve this, you would use the <code>basicConfig()</code> method.
<pre><code class="lang-python">import logging
</code></pre>
<pre><code class="lang-python">logging.basicConfig(level = logging.INFO, filename = &#39;datacamp.log&#39;)
</code></pre>
<pre><code class="lang-python">logging.debug(&quot;A Debug Logging Message&quot;)
</code></pre>
<pre><code class="lang-python">logging.info(&quot;A Info Logging Message&quot;)
</code></pre>
<pre><code class="lang-python">logging.warning(&quot;A Warning Logging Message&quot;)
</code></pre>
<pre><code class="lang-python">logging.error(&quot;An Error Logging Message&quot;)
</code></pre>
<pre><code class="lang-python">logging.critical(&quot;A Critical Logging Message&quot;)
</code></pre>
<a id='log1'></a>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1584715063/logging2_ovbrzd.png" style="width:100%">
</figure>

As you can see, now the logs are being generated in a log file <code>datacamp.log</code>. Upon running the above cells multiple times, you would notice that logs will be added in the log file that many times. By default, the file is in <code>append</code> mode.
<a id='log1'></a>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1584715063/logging3_crzayi.png" style="width:100%">
</figure>

You can make use of the <code>filemode</code> keyword to prevent the log file from being written with multiple copies of logs i.e., append mode. The filemode can be changed to <code>write</code> mode, which will overwrite the previous logs and only save the current ones. Since the filemode is set to <code>w</code>, this means that the log file will be opened in <code>write mode</code> each time <code>basicConfig()</code> is run, which will ultimately overwrite the file.
The file mode functionality in logging is similar to a standard file handling that Python offers.
<pre><code class="lang-python">import logging
</code></pre>
<pre><code class="lang-python">logging.basicConfig(level = logging.INFO, filename = &#39;datacamp.log&#39;, filemode = &#39;w&#39;)
</code></pre>
<pre><code class="lang-python">logging.debug(&quot;A Debug Logging Message&quot;)
logging.info(&quot;A Info Logging Message&quot;)
logging.warning(&quot;A Warning Logging Message&quot;)
logging.error(&quot;An Error Logging Message&quot;)
logging.critical(&quot;A Critical Logging Message&quot;)
</code></pre>
Let&#39;s run the above lines of code multiple times. You will notice that this time only the current log entries will be saved, and the previous ones will be overwritten, as shown below.
<a id='log1'></a>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1584715063/logging4_eara4d.png" style="width:100%">
</figure>

Let&#39;s look at some more logging attributes like date, time, line number at which warning or error was generated. Well, as you might agree by now that all these are advantages over a simple Print function and is far more capable than a mere Print function.
In order for you to accomplish this, you will pass the logging attributes <code>asctime</code> and <code>lineno</code>. Also you will pass the <code>message</code> attribute, which will be a placeholder for the message you would like to display for the logs. All these attributes will be passed to the <code>format</code> method. 
<pre><code class="lang-python">import logging
</code></pre>
<pre><code class="lang-python">logging.basicConfig(format=&#39;Date-Time : %(asctime)s : Line No. : %(lineno)d - %(message)s&#39;, \
 level = logging.DEBUG)
</code></pre>
<pre><code class="lang-python">logging.debug(&quot;A Debug Logging Message&quot;)
logging.info(&quot;A Info Logging Message&quot;)
logging.warning(&quot;A Warning Logging Message&quot;)
logging.error(&quot;An Error Logging Message&quot;)
logging.critical(&quot;A Critical Logging Message&quot;)
</code></pre>
<pre><code>Date-Time : 2020-03-18 23:58:12,429 : Line No. : 1 - A Debug Logging Message
Date-Time : 2020-03-18 23:58:12,436 : Line No. : 2 - A Info Logging Message
Date-Time : 2020-03-18 23:58:12,437 : Line No. : 3 - A Warning Logging Message
Date-Time : 2020-03-18 23:58:12,440 : Line No. : 4 - An Error Logging Message
Date-Time : 2020-03-18 23:58:12,441 : Line No. : 5 - A Critical Logging Message
</code></pre>Let&#39;s look at the definitions of each attribute straight from this <a href="#table">table</a>.
<ul>
<li><code>asctime</code>: Human-readable time when the LogRecord was generated. By default, this is of the form <code>2020-03-18 22:24:42,670</code> (the numbers after the comma are millisecond portion of the time). Since this attribute is a string, hence, you use <code>s</code> keyword after it.
</li>
<li><code>lineno</code>: Source line number where the logging call was called. Since this attribute is an integer, hence, you use <code>d</code> keyword after it.
</li>
<li><code>message</code>: The logged message, computed as msg % args. This is set when Formatter.format() is invoked. If you do not specify this attribute while using the format() parameter, the messages you wish to log will not be generated. Similarly, for a message attribute, you use <code>s</code> since its a string.
</li>
<li><code>funcName</code>: This will output the module or the function name in which the log is generated. It is useful when you have a lot of functions in your code, and you want to segregate the logs based on the function or method they belong to.
</li>
</ul>
Let&#39;s take a simple example and see how you can plug in the logging debug function in place of the print function.
<pre><code class="lang-python">import logging

logging.basicConfig(format=&#39;%(asctime)s :: %(levelname)s :: %(funcName)s :: %(lineno)d \
:: %(message)s&#39;, level = logging.INFO)

def addition(x, y):
 add = x + y
 return add


def subtract(x, y):
 sub = x - y
 return sub


def multiply(x, y):
 mul = x * y
 return mul


def divide(x, y):
 div = x / y
 return div

def exponent(x, y):
 exp = x ** y
 return exp


num1 = 20
num2 = 2

def main():
 add_result = addition(num1, num2)
 logging.info(&#39;Add: {} + {} = {}&#39;.format(num1, num2, add_result))

 sub_result = subtract(num1, num2)
 logging.info(&#39;Sub: {} - {} = {}&#39;.format(num1, num2, sub_result))

 mul_result = multiply(num1, num2)
 logging.info(&#39;Mul: {} * {} = {}&#39;.format(num1, num2, mul_result))

 div_result = divide(num1, num2)
 logging.info(&#39;Div: {} / {} = {}&#39;.format(num1, num2, div_result))

 exp_result = exponent(num1, num2)
 logging.info(&#39;Exp: {} ** {} = {}&#39;.format(num1, num2, exp_result))


main()
</code></pre>
<pre><code>2020-03-19 00:01:27,372 :: INFO :: main :: 35 :: Add: 20 + 2 = 22
2020-03-19 00:01:27,376 :: INFO :: main :: 38 :: Sub: 20 - 2 = 18
2020-03-19 00:01:27,377 :: INFO :: main :: 41 :: Mul: 20 * 2 = 40
2020-03-19 00:01:27,378 :: INFO :: main :: 44 :: Div: 20 / 2 = 10.0
2020-03-19 00:01:27,379 :: INFO :: main :: 47 :: Exp: 20 ** 2 = 400
</code></pre><h1 id="conclusion">Conclusion</h1>
Congratulations on finishing the tutorial.
You might want to try out other logging attributes and understand how they can be leveraged in your code.
Please feel free to ask any questions related to this tutorial in the comments section below.
If you are just getting started in Python and would like to learn more, take DataCamp&#39;s <a href="https://learn.datacamp.com/courses/introduction-to-data-science-in-python">Introduction to Data Science in Python</a> course.

https://www.datacamp.com/community/tutorials/logging-in-python

Learn about the fundamentals of Logging in Python.

(Tutorial) Logging in Python

Logging in Python

If you are just getting started in Python and would like to learn more, take DataCamp&#39;s <a href="https://learn.datacamp.com/courses/introduction-to-data-science-in-python">Introduction to Data Science in Python</a> course.
Dictionary is a built-in Python Data Structure that is mutable. It is similar in spirit to List, Set, and Tuples. However, it is not indexed by a sequence of numbers but indexed based on <code>keys</code> and can be understood as associative arrays. On an abstract level, it consists of a <code>key</code> with an associated <code>value</code>. In Python, the Dictionary represents the implementation of a <code>hash-table</code>.
<h4 id="you-might-wonder-what-are-keys-">You might wonder what are keys?</h4>
Well, as shown in the figure below, keys are immutable ( which cannot be changed ) data types that can be either strings or numbers. However, a key can not be a mutable data type, for example, a list. Keys are unique within a dictionary and can not be duplicated inside a dictionary, in case if it is used more than once then subsequent entries will overwrite the previous value.
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1584113961/dictionary2_obxo0j.jpg"></center>

<code>Key</code> connects with the <code>value</code>, hence, creating a map-like structure. If you for a second, remove keys from the picture, all you are left with is a data structure containing a sequence of numbers. Dictionaries, therefore, hold a <code>key: value</code> pair at each position.
A dictionary is represented by a pair of curly braces <code>{}</code> in which enclosed are the <code>key: value</code> pairs separated by a comma.
Let&#39;s look at the syntax of a dictionary:
dictionary = {&quot;key_1&quot;: &quot;value_1&quot;, &quot;key_2&quot;: &quot;value_2&quot;, &quot;key_3&quot;: &quot;value_3&quot;}#
<h3 id="unique-keys">Unique Keys</h3>
Since now you know that <code>keys</code> in a dictionary have to be unique, let&#39;s understand it with the help of an example.
<pre><code class="lang-python">dictionary_unique = {&quot;a&quot;: &quot;alpha&quot;, &quot;o&quot;: &quot;omega&quot;, &quot;g&quot;: &quot;gamma&quot;}
</code></pre>
Let&#39;s print this out.
<pre><code class="lang-python">print(dictionary_unique)
</code></pre>
<pre><code>{&#39;a&#39;: &#39;alpha&#39;, &#39;o&#39;: &#39;omega&#39;, &#39;g&#39;: &#39;gamma&#39;}
</code></pre>Great, so until now, everything looks fine. You were able to print your first dictionary output. Now, let&#39;s repeat the key <code>g</code> with a new value and see what happens.
<pre><code class="lang-python">dictionary_unique = {&quot;a&quot;: &quot;alpha&quot;, &quot;o&quot;: &quot;omega&quot;, &quot;g&quot;: &quot;gamma&quot;, &quot;g&quot;: &quot;beta&quot;}
</code></pre>
<pre><code class="lang-python">print(dictionary_unique)
</code></pre>
<pre><code>{&#39;a&#39;: &#39;alpha&#39;, &#39;o&#39;: &#39;omega&#39;, &#39;g&#39;: &#39;beta&#39;}
</code></pre>As expected, the key <code>g</code> previous value <code>gamma</code> was overwritten by value <code>beta</code>.
<h3 id="immutable-keys">Immutable Keys</h3>
Now let&#39;s see what happens when you try to define the <code>key</code> as a mutable data type.
<pre><code class="lang-python">dictionary_immutable = {[&quot;a&quot;,&quot;b&quot;,&quot;c&quot;]: &quot;alpha&quot;, &quot;o&quot;: &quot;omega&quot;, &quot;g&quot;: &quot;gamma&quot;, &quot;g&quot;: &quot;beta&quot;}
</code></pre>
<pre><code>---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

&lt;ipython-input-16-78a55d50cd65&gt; in &lt;module&gt;
----&gt; 1 dictionary_immutable = {[&quot;a&quot;,&quot;b&quot;,&quot;c&quot;]: &quot;alpha&quot;, &quot;o&quot;: &quot;omega&quot;, &quot;g&quot;: &quot;gamma&quot;, &quot;g&quot;: &quot;beta&quot;}


TypeError: unhashable type: &#39;list&#39;
</code></pre>From the above output, you can observe that defining the first key of the dictionary as a list results in a <code>TypeError</code> since dictionary keys must be immutable types and list is a mutable type.
However, there is a workaround to it, which is, replacing the list to a tuple, since a tuple is an immutable data type.
<pre><code class="lang-python">dictionary_immutable = {(&quot;a&quot;,&quot;b&quot;,&quot;c&quot;): &quot;alpha&quot;, &quot;o&quot;: &quot;omega&quot;, &quot;g&quot;: &quot;gamma&quot;, &quot;g&quot;: &quot;beta&quot;}
</code></pre>
<pre><code class="lang-python">dictionary_immutable
</code></pre>
<pre><code>{(&#39;a&#39;, &#39;b&#39;, &#39;c&#39;): &#39;alpha&#39;, &#39;o&#39;: &#39;omega&#39;, &#39;g&#39;: &#39;beta&#39;}
</code></pre><h3 id="accessing-keys-and-values">Accessing Keys and Values</h3>
Since you now know how to create dictionaries, let&#39;s learn to access the keys and the values from the dictionary. To access the key value pair, you would use the <code>.items()</code> method, which will return a list of <code>dict_items</code> in the form of a key, value tuple pairs.
<pre><code class="lang-python">dictionary_unique.items()
</code></pre>
<pre><code>dict_items([(&#39;a&#39;, &#39;alpha&#39;), (&#39;o&#39;, &#39;omega&#39;), (&#39;g&#39;, &#39;beta&#39;)])
</code></pre>To access keys and values separately, you could use a for loop on the dictionary or the <code>.keys()</code> and <code>.values()</code> method.
<pre><code class="lang-python">for key, value in dictionary_unique.items(): #accessing keys
 print(key,end=&#39;,&#39;)
</code></pre>
<pre><code>a,o,g,
</code></pre><pre><code class="lang-python">for key, value in dictionary_unique.items(): #accessing values
 print(value,end=&#39;,&#39;)
</code></pre>
<pre><code>alpha,omega,beta,
</code></pre><pre><code class="lang-python">dictionary_unique.keys() #accessing keys without for loop
</code></pre>
<pre><code>dict_keys([&#39;a&#39;, &#39;o&#39;, &#39;g&#39;])
</code></pre><pre><code class="lang-python">dictionary_unique.values() #accessing values without for loop
</code></pre>
<pre><code>dict_values([&#39;alpha&#39;, &#39;omega&#39;, &#39;beta&#39;])
</code></pre>You could even access a value by specifying a key as a parameter to the dictionary.
<pre><code class="lang-python">dictionary_unique[&#39;a&#39;]
</code></pre>
<pre><code>&#39;alpha&#39;
</code></pre><pre><code class="lang-python">dictionary_unique[&#39;g&#39;]
</code></pre>
<pre><code>&#39;beta&#39;
</code></pre><h3 id="nested-dictionary">Nested Dictionary</h3>
Creating a nested dictionary is quite simple. In the nested dictionary, you pass in a dictionary inside a dictionary or to put it simply; a dictionary is passed as a value to a key of the main dictionary.
Here you will create a <code>datacamp</code> dictionary inside a nested dictionary <code>dictionary_nested</code>.
<pre><code class="lang-python">dictionary_nested = {&quot;datacamp&quot;:{&quot;Deep Learning&quot;: &quot;Python&quot;, &quot;Machine Learning&quot;: &quot;Pandas&quot;},&quot;linkedin&quot;:&quot;jobs&quot;,&quot;nvidia&quot;:&quot;hardware&quot;}
</code></pre>
<pre><code class="lang-python">dictionary_nested
</code></pre>
<pre><code>{&#39;datacamp&#39;: {&#39;Deep Learning&#39;: &#39;Python&#39;, &#39;Machine Learning&#39;: &#39;Pandas&#39;},
 &#39;linkedin&#39;: &#39;jobs&#39;,
 &#39;nvidia&#39;: &#39;hardware&#39;}
</code></pre><pre><code class="lang-python">dictionary_nested[&#39;datacamp&#39;][&#39;Deep Learning&#39;]
</code></pre>
<pre><code>&#39;Python&#39;
</code></pre><pre><code class="lang-python">dictionary_nested[&#39;datacamp&#39;][&#39;Machine Learning&#39;]
</code></pre>
<pre><code>&#39;Pandas&#39;
</code></pre><pre><code class="lang-python">dictionary_nested[&#39;linkedin&#39;]
</code></pre>
<pre><code>&#39;jobs&#39;
</code></pre><pre><code class="lang-python">dictionary_nested[&#39;nvidia&#39;]
</code></pre>
<pre><code>&#39;hardware&#39;
</code></pre><h3 id="dictionary-comprehension">Dictionary Comprehension</h3>
Dictionary comprehensions can be used to create dictionaries from arbitrary key and value expressions. It is a simple and concise way of creating dictionaries and is often faster than the usual <code>for</code> loop implementations.
<pre><code class="lang-python">import time
t1 = time.time()
dict_comprehension = {i: i**3 for i in range(200000)}
print(time.time() - t1)
</code></pre>
<pre><code>0.0897526741027832
</code></pre>Let&#39;s print the first ten key: value pairs from the <code>dict_comprehension</code> dictionary. To achieve this, you will import <code>islice</code> from the <code>itertools</code> built-in package and specify <code>n</code> as a number of key value pairs you want to extract.
<pre><code class="lang-python">from itertools import islice

comp_10 = list(islice(dict_comprehension.items(),10))
print(comp_10)
</code></pre>
<pre><code>[(0, 0), (1, 1), (2, 8), (3, 27), (4, 64), (5, 125), (6, 216), (7, 343), (8, 512), (9, 729)]
</code></pre><pre><code class="lang-python">import time
t1 = time.time()
dict_comprehension = dict()
for i in range(200000):
 dict_comprehension[i+1] = i**3
print(time.time() - t1)
</code></pre>
<pre><code>0.10853934288024902
</code></pre>As you can see from the above two implementations of a dictionary, dictionary comprehension with a minimal margin, is still the winner in terms of the time it takes to run. You would notice that as you keep increasing the <code>range</code> parameter, the difference in the time will also increase.
<h3 id="word-frequency">Word Frequency</h3>
From a collection of written texts, in this case, a string of text, also known as <code>corpus</code>, lets us create a word frequency with the help of a dictionary.
<pre><code class="lang-python">corpus = &#39;learn all about the Python Dictionary and its potential. \
 You would also learn to create word frequency using the Dictionary&#39;
</code></pre>
<pre><code class="lang-python">word_freq = dict()
corpus_word = str(corpus).split()
for word in range(len(corpus_ref)):
 if corpus_word[word] not in word_freq:
 word_freq[corpus_word[word]] = 1

 else:
 word_freq[corpus_word[word]] += 1
</code></pre>
<pre><code class="lang-python">word_freq
</code></pre>
<pre><code>{&#39;learn&#39;: 2,
 &#39;all&#39;: 1,
 &#39;about&#39;: 1,
 &#39;the&#39;: 2,
 &#39;Python&#39;: 1,
 &#39;Dictionary&#39;: 2,
 &#39;and&#39;: 1,
 &#39;its&#39;: 1,
 &#39;potential.&#39;: 1,
 &#39;You&#39;: 1,
 &#39;would&#39;: 1,
 &#39;also&#39;: 1,
 &#39;to&#39;: 1,
 &#39;create&#39;: 1,
 &#39;word&#39;: 1,
 &#39;frequency&#39;: 1,
 &#39;using&#39;: 1}
</code></pre>Great! So as you can observe from the above output, you were able to get a word count or word frequency from a string of text with the help of a Python Dictionary.
<h1 id="conclusion">Conclusion</h1>
Congratulations on finishing the tutorial.
Please feel free to ask any questions related to this tutorial in the comments section below.
If you are just getting started in Python and would like to learn more, take DataCamp&#39;s <a href="https://learn.datacamp.com/courses/introduction-to-data-science-in-python">Introduction to Data Science in Python</a> course.

https://www.datacamp.com/community/tutorials/dictionary-python

Learn all about the Python Dictionary and its potential. You will also learn how to create word frequency using the Dictionary.

Learn all about the PYTHON Dictionary and its potential. You will also learn how to create word frequency using the DICTIONARY.

(Tutorial) Python Dictionaries: The Definitive Guide

Python Dictionaries: The Definitive Guide

<center>
<a target=“_blank” href="https://www.datacamp.com/learn/r/"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1604679611/BANNER_mrsctv.png" /></a>
</center> 
R is one of the main languages used for data science today. As such, it is natural that any beginner may want to know how to get started with this powerful language regardless of the operating system running on a computer. Thus, this tutorial will address this by covering the installation process of R on Windows 10, Mac OSX, and Ubuntu Linux.
Furthermore, it will also go over the installation of RStudio, which is an IDE (Integrated Development Environment) that makes R easier to use as well as how to install R packages such as dplyr or ggplot2.
<h2 id="installing-r-on-windows-10">Installing R on Windows 10</h2>
Installing R on Windows 10 is very straightforward. The easiest way is to install it through CRAN, which stands for The Comprehensive R Archive Network. Just visit the <a href="https://cran.r-project.org/">CRAN downloads</a> page and follow the links as shown in the video below:
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583946484/ezgif.com-resize_zzbzbg.gif" /></center>

Once the download is finished, you will obtain a file named &quot;R-3.6.3-win.exe&quot; or similar depending on the version of R that you download. The links shown in the video above will take you to the most recent version. To finish installing R on your computer, all that is left to do is to run the .exe file. Most of the time, you will likely want to go with the defaults, so click the button &#39;Next&#39; until the process is complete, as shown in the video below. Note that, even though I do not do so, you can add desktop or quick start shortcuts during the process.
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583946566/ezgif.com-resize_1_pnz4tu.gif" /></center>

<h3 id="installing-rstudio">Installing RStudio</h3>
Once R is installed, you can proceed to install the RStudio IDE to have a much-improved environment to work in your R scripts. It includes a console that supports direct code execution and tools for plotting and keeping track of your variables in the workspace, among other features. The installation process is very straightforward, as well. Simply go to the <a href="https://rstudio.com/products/rstudio/download/#download">RStudio downloads page</a> and follow the video below:
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583946691/ezgif.com-video-to-gif_6_pz7f09_x4spfr.gif" /></center>

Once the download is complete, you will get a file named &quot;RStudio-1.2.5033.exe&quot; or similar. Again this will be dependent on the version. To complete the installation, it is as easy as before. Just run the previously mentioned .exe file with the default settings by clicking &#39;Next&#39;, and wait until the installation finishes. Bear in mind that RStudio requires that R is installed beforehand.
<h3 id="installing-packages-in-r">Installing Packages in R</h3>
Now you have base R installed on your system and a nice IDE to begin your R programming journey. However, base R is rather limited in the things that it can do, which is why we have R packages such as dplyr for enhanced data-wrangling capabilities or ggplot2 for improved data visualizations. There are two simple ways to install R packages using RStudio. The first is to execute the following line of code in the console:
<code>install.packages(c(&quot;dplyr&quot;,&quot;ggplot2&quot;))</code>
The second is shown in the video below. It is an easy-to-use graphical interface built into RStudio from which you can search and download any R package available on CRAN.
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583946948/ezgif.com-resize_3_usjbvk.gif" /></center>

<h2 id="installing-r-on-mac-osx">Installing R on Mac OSX</h2>
 Installing R on Mac OS is similar to Windows. Once again, The easiest way is to install it through CRAN by going to the <a href="https://cran.r-project.org/">CRAN downloads</a> page and following the links as shown in the video below:
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583947086/ezgif.com-resize_4_pmdxfv.gif" /></center>

The next step is to click on the &quot;R-3.6.2.pkg&quot; (or newer version) file to begin the installation. You can leave the default options as is just like for Windows.
<h3 id="installing-rstudio-and-r-packages">Installing RStudio and R packages</h3>
This process is essentially the same as in Windows. To download RStudio, go to the <a href="https://rstudio.com/products/rstudio/download/#download">RStudio downloads page</a> and get the .dmg for Mac OS, as shown in the image below. Remember to keep default installation options.
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583354177/Img1_a2bfpu.png" /></center>

Once you open RStudio, installing packages is the same as with Windows. You can use either <code>install.packages(c(&quot;dplyr&quot;,&quot;ggplot2&quot;))</code> in the console or go ahead and use the graphical interface shown in the video under the installing packages in R subsection of this tutorial.
<h2 id="installing-r-on-ubuntu-19-04-18-04-16-04">Installing R on Ubuntu 19.04/18.04/16.04</h2>
Installing R on Ubuntu maybe a little bit more tricky for those unused to working in the command line. However, it is perhaps just as easy as with Windows or Mac OS. Before you start, make sure to have root access in order to use sudo.
As it is common, prior to installing R, let us update the system package index and upgrade all our installed packages using the following two commands:
<code>sudo apt update</code>
<code>sudo apt -y upgrade</code>
After that, all that you have to do is run the following in the command line to install base R.
<code>sudo apt -y install r-base</code>
<h3 id="installing-rstudio-and-r-packages">Installing RStudio and R Packages</h3>
Once base R is installed, you can go ahead and install RStudio. For that we are going to head over again to the <a href="https://rstudio.com/products/rstudio/download/#download">RStudio downloads page</a> and download the .deb file for our Ubuntu version as shown in the image below:
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583354178/Img2_q3uwjt.png" /></center>

Once you have the .deb file, all that is left is to navigate to your downloads folder using <code>cd Downloads</code> in the command line and then run the following command to begin the installation process:
<code>sudo dpkg -i rstudio-1.2.5033-amd64.deb</code>
You may encounter some dependency problems that may cause your first try to install RStudio to fail, but this has an easy fix. Just run the following command and try again:
<code>sudo apt -f install</code>
When the process finishes, you will have an RStudio shortcut in your Ubuntu app list, but you will also be able to start RStudio by typing rstudio in the command line.
Once you open RStudio, installing packages can be done in the exact same manner as with Windows or Mac OS. Either by typing <code>install.packages(c(&quot;dplyr&quot;,&quot;ggplot2&quot;))</code> in the console or using the graphical interface shown in the video under the installing packages in R subsection of this tutorial
<h2 id="conclusion">Conclusion</h2>
I hope that this tutorial will help those of you eager to dive into the world of R programming regardless of your operating system choice. If you are looking to start learning R as such after installing it, please refer to the <a href="https://www.datacamp.com/courses/free-introduction-to-r">Introduction to R</a> course, which will guide you through the basics of R programming. Keep learning; the sky is the limit.

https://www.datacamp.com/community/tutorials/installing-R-windows-mac-ubuntu

This is a beginner guide that is designed to save yourself a headache and valuable time if you decide to install R yourself.

(Tutorial) How to Install R on Windows, Mac OS X, and Ubuntu

How to Install R on Windows, Mac OS X, and Ubuntu

If you would like to learn Tableau, take DataCamp&#39;s <a href="https://www.datacamp.com/courses/introduction-to-tableau">Introduction to Tableau</a> course.
<h3 id="connecting-to-the-dataset">Connecting to the Dataset</h3>
The dataset has been taken from the Airbnb <a href="http://insideairbnb.com/get-the-data.html">website</a>. We will use the listings.csv file of New York City, NY (2019), which describes the listing activity and its other metrics. All information about hosts, geographical availability, and price has been included to make exciting visualizations.
To connect to your file, go to <code>Connect -&gt; Text file -&gt; Choose file path -&gt; Open</code>
<center><a href="https://www.datacamp.com/courses/introduction-to-tableau"><img src = "https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583348142/1_u6ymas.png" /></a></center>

A quick glance over the data will look something like this:
<center><a href="https://www.datacamp.com/courses/introduction-to-tableau"><img src = "https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583348142/2_y8mo8a.png" /></a></center>

<h3 id="what-are-measure-names-and-measure-values-">What are Measure Names and Measure Values?</h3>
As soon as you load the Excel file and open a new worksheet in Tableau, it will automatically categorize all the column headings of your file into one of the below categories (as seen in the Data pane):
<ul>
<li>Dimensions</li>
<li>Measures</li>
</ul>
Notice that Tableau mistakenly classifies <code>Reviews Per Month</code> into <code>Dimensions</code>. Correct this by dragging the field into the <code>Measures</code> pane, as we want to use this field as a continuous numerical variable.
Apart from the column names, the Date pane will always contain a number of fields that do not come from your original data, two of which are Measure Values and Measure Names. Tableau automatically creates these fields so that you can build certain types of views that involve multiple measures. [1]
This article is going to focus on how we can use these multiple measures.
<a href="https://www.datacamp.com/courses/introduction-to-tableau"><img src = "https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583348142/3_ibkimd.png" /></a>
<ul>
<li>The Measure Values field always appears at the bottom of the Measures area in the Data pane and contains all the measures in your data, collected into a single field with continuous values. [2]
</li>
<li>The Measure Names field always appears at the bottom of the Dimensions area in the Data pane and contains the names of all measures in your data, collected into a single field with discrete values. [3]
</li>
</ul>
 [1][2][3] <a href="https://help.tableau.com/current/pro/desktop/en-us/datafields_understanddatawindow_meavalues.htm">Official Tableau documentation</a>
<h3 id="tablulating-measure-names-and-measure-values">Tablulating Measure Names and Measure Values</h3>
Let&#39;s start by first dragging the Measure Names field in the view. Next, drag the Measure Values field directly into the view or under the Text section in the Marks card. You will see a table with variable names against default aggregations applied to the corresponding numerical variables.
You may remove some measures values (which you do not want to be included) by dragging them out of the Measure Values card.
<center><a href="https://www.datacamp.com/courses/introduction-to-tableau"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583349004/ezgif.com-video-to-gif_3_pewghr.gif" /></a></center>



We know that <code>Dimensions</code> are types of categories, and <code>Measures</code> are the numerical values that we want to examine across such categories. So, let&#39;s see how we can tabulate multiple dimensions across multiple measures.
We would like to cross-tabulate multiple dimensions with multiple measures. Begin by simply dragging two-dimension fields, say <code>Neighbourhood Group</code> into the Rows tab and <code>Room Type</code> into the Columns tab. You will see a nice 5x3 table containing 5 neighbourhood groups and 3 room types.
<center><a href="https://www.datacamp.com/courses/introduction-to-tableau"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583348142/5_htnjjl.png" /></a></center>

Now suppose you want to show both the <code>Price</code> and the <code>Number of Reviews</code> for each <code>Neighbourhood Group</code> and <code>Room Type</code>. First drag <code>Price</code> into the view. Next, when you add <code>Number of Reviews</code> to the text table (by dragging it and dropping it in the view), the measures are combined, and the <code>Measure Values</code> field is added to Marks Text Card. Notice that the <code>Measure Names</code> field is automatically added to the Rows shelf.
It is vital to use <code>Measure Names</code> whenever dealing with more than one measure value.
<h4 id="aggregate-functions">Aggregate functions</h4>
Similar to the aggregate functions (SUM, AVG, MEAN, COUNT) that we have in MySQL, PostgreSQL, etc., Tableau also provides a number of aggregate functions for its <code>Measures</code>.
An aggregate function performs a calculation on a set of values and returns a single value.
Here, since we would like to see the average price (and not the total price of all rooms) of each room type in different neighborhoods, we change the (default) aggregate function of <code>Price</code> from <code>SUM()</code> to <code>AVG()</code> using the Measure Values card.
<h3 id="tabulating-multiple-measure-names-and-measure-values">Tabulating Multiple Measure Names and Measure Values</h3>
<center><a href="https://www.datacamp.com/courses/introduction-to-tableau"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583348470/ezgif.com-video-to-gif_sfxbyz.gif" /></a></center>



Looks good! But there are too many numbers to comprehend. To get better insights, let&#39;s go ahead and make a graphical representation of the same data.
Select the Horizontal Bars graph using the Show Me button on the top right corner of Tableau. You will see a bar for the <code>AVG(PRICE)</code> and <code>SUM(NUMBER OF REVIEWS)</code> for each Neighborhood Group and Room Type.
Make it neater by color-coding the bars according to the <code>Neighborhood Group</code>. Tableau automatically creates and displays a legend for the same. Lastly, swap the rows and columns to make the graph more intuitive and understandable.
The graph now clearly shows the pricing and popularity (number of reviews) trends for every locality and room type.
<center><a href="https://www.datacamp.com/courses/introduction-to-tableau"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583348610/ezgif.com-video-to-gif_1_cke5b0.gif" /></a></center>


It is always a good idea to use a geographical map when dealing with places, latitudes and longitudes. Below are the steps on how you can convert your same data into a beautiful geographical visualization.
<h3 id="visualization-using-map">Visualization using Map</h3>
We will again use the <code>Color</code> mark to classify and color each (latitude, longitude) pair into its
associated neighborhood group.
Similarly, we will use the <code>Size</code> mark to indicate the range of prices of the Airbnb
properties. Larger circles denote higher prices, and smaller circles denote lower prices.
Both the color and size legends can be found on the right.
<center><a href="https://www.datacamp.com/courses/introduction-to-tableau"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583348824/ezgif.com-video-to-gif_2_bbgkbx.gif" /></a></center>



<h3 id="conclusion">Conclusion</h3>
In this article, we saw how Tableau automatically segregates your data fields into <code>Dimensions</code> and <code>Measures</code>. In case it misclassifies any column, we can easily drag-and-drop the field to its correct category.
We also cross-tabulated multiple dimensions with multiple measures using different visualizations - Text Table, Bar Graph, and Map.
We explored how we can use the <code>Color</code> and <code>Size</code> options in the Marks card. In addition, we experimented with some aggregate functions like <code>SUM()</code> and <code>AVG()</code> to draw meaningful inferences.
If you would like to learn more about Tableau, take DataCamp&#39;s <a href="https://www.datacamp.com/courses/introduction-to-tableau">Introduction to Tableau</a> course.

https://www.datacamp.com/community/tutorials/tableau-visualizations-with-measure-names-and-measure-values

Learn about different categories of variables in Tableau and how they can be leveraged to analyze data through insightful visualizations.

Learn about different categories of variables in TABLEAU and how they can be leveraged to analyze DATA through insightful VISUALIZATIONS.

(Tutorial) Creating Tableau Visualizations Using Airbnb Dataset

Creating Tableau Visualizations Using Airbnb Dataset

<center>
<a target=“_blank” href="https://www.datacamp.com/learn/python/"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582839819/python_4_t5pp5t.png" /></a>
</center> 

<h2 id="virtual-environment-in-python">Virtual Environment in Python</h2>
Learn about the Virtual Environment and two different ways for creating it: Pipenv is mostly used by web developers and Anaconda distributions for data scientists where Virtual Environment is created from &#39;conda&#39; through &#39;Anaconda Prompt&#39;. It also has an alternative option to create from Anaconda Navigator.
Virtual Environment is used to create a container or isolated environment where the Python-related dependencies are installed for a specific project. One can work with many different versions of Python with its various packages. Data scientists tend to use Anaconda distribution, which comes with many useful pre-installed packages, which are easy to install and manage. A web developer who uses Django, Flask, and other Python-related frameworks can use Pipenv as their Virtual Environment.
<h2 id="pipenv">Pipenv</h2>
Pipenv is a new and popular way of automatically creating a &#39;virtualenv&#39; for the project. It creates a Pipfile, which helps to manage the package and can be installed or removed easily.
Through Pipenv, &#39;pip&#39; and &#39;virtualenv&#39; can be used together to create a Virtual Environment, Pipfile works as the replacement of the &#39;requirement.txt.&#39; which tracks the package version according to the given project.
This tutorial uses Git Bash as the terminal in the Windows Operating System. However, for Mac users, Homebrew could be used, which is the package management tool, and similarly, LinuxBrew could be used for Linux users.
Let&#39;s create a project using the &#39;mkdir project-name&#39; command, which stands for making a directory with the project name as &#39;new-project&#39; and move to the newly created directory by using &#39;cd&#39; command. 
<img src="https://i.imgur.com/5qySqkp.png">
Windows users can use the following command to install &#39;pipenv&#39;.
<code>pip install pipenv</code>
Linux/Mac Users can use the following command to install &#39;pipenv&#39; after installing LinuxBrew.
<code>brew install pipenv</code>
<h3 id="creating-a-virtualenv-for-the-project">Creating a virtualenv for the project</h3>
For creating the &#39;virtualenv&#39; for the project, use the following command. 
<code>pipenv shell</code>
The command &#39;pipenv&#39; creates a new &#39;virtualenv&#39; for the project along with Pipfile side by side.
<img src="https://i.imgur.com/Nx0xcLT.png">
<h3 id="installing-uninstalling-required-packages-for-the-project">Installing/UnInstalling required packages for the project</h3>
You&#39;ll install the two package named &#39;requests&#39; and &#39;flask&#39; in your Virtual Environment using the following command. 
<code>pipenv install requests</code> 
<code>pipenv install flask</code> 
The following changes are seen after the installation of the two packages.
<img src="https://i.imgur.com/C0ctmre.png">
For the uninstallation of the package, use the following command. 
<code>pipenv uninstall flask</code>
<h3 id="exiting-from-the-virtual-environment">Exiting from the Virtual Environment</h3>
You can use the following command to deactivate form the current environment.
<code>exit</code>
<h2 id="anaconda">Anaconda</h2>
Anaconda is the most popular platform used by data scientists and machine learning engineers. It consists of &#39;Conda&#39;, which helps in managing the environment, libraries, and dependencies.
<h2 id="installing-anaconda-for-python-virtual-environment-manager">Installing Anaconda for Python Virtual Environment Manager</h2>
<ul>
<li>Windows users can head over to the following tutorial to set up the Anaconda distribution. </li>
<a href="https://medium.com/@GalarnykMichael/install-python-on-windows-anaconda-c63c7c3d1444">Install Anaconda Windows</a> 
<li>Linux/Mac Users then head over to the following tutorial to set up the Anaconda distribution. </li>
<a href="https://www.datacamp.com/community/tutorials/installing-anaconda-mac-os-x">Install Anaconda Mac/Linux</a> 
</ul>
Use the Anaconda version of 4.6 or newer. There are slight changes in the command for the previous version. If you are running older versions, use the following command for an update. 
<code>conda update conda</code>
One of two ways can be used in the creation of the Virtual Environment, which is shown below.
<ul>
 <li>Anaconda Prompt-It is a command-line tool that comes after the installation of Anaconda distribution.</li>
 <li>Anaconda Navigator-It is a Graphical User Interface that serves as an alternative tool to launch and manage packages in Anaconda.</li>

This tutorial uses Windows Operating System but works with any Operating System. There might be some minor changes in the Anaconda command, but the overall creation process for Virtual Environment is the same.
You can open &quot;Terminal&quot; in Mac/Linux to achieve the following result.
According to the requirements needed for the projects, the following guides serve more detail in the creation of a Virtual Environment. 
<a href="https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html">Managing environments</a>
<h2 id="anaconda-prompt">Anaconda Prompt</h2>
Press the &quot;Windows&quot; icon in the lower corner of the screen to open the &quot;Search&quot; box. Type &quot;Anaconda Prompt&quot; and then hit &quot;Enter&quot; to open it. Use <code>conda</code> to check Anaconda has been successfully installed in your system; the following changes could be seen.
<img src="https://i.imgur.com/hyDvwZM.png" /> 
<ol>
<li>Creating a new Virtual Environment. 
The following command takes &#39;-n&#39; as a flag, which is for creating a new environment with its name as &#39;env&#39; and the specific Python version of &#39;3.7&#39;.
<code>conda create -n env python = 3.7</code> 
</li>
<li>Activating the Virtual Environment. 
The command below activates the Virtual Environment, which changes the prompt where the &#39;env&#39; is shown in parenthesis.
<code>conda activate env</code>
<img src = "https://i.imgur.com/rhGNPIY.png"> 
</li>
<li>Install the required package. 
For example, the &#39;numpy&#39; package is installed where &#39;env&#39; is the specific Virtual Environment. 
<code>conda install -n env numpy</code> 
OR 
Also, Python Package manager could be used to install &#39;numpy&#39;.
<code>pip install numpy</code> 
<img src="https://i.imgur.com/uE2pSHM.png"> 
</li>
<li>Listing all of the installed packages inside a Virtual Environment. 
The following command can list the package specific to the Virtual Environment.
<code>conda list</code> <img src="https://i.imgur.com/KhJqbDu.png"> 
</li>
<li>Listing out all of the created Virtual Environment. 
All of the environments created will be listed by the following command.
<code>conda env list</code>
<img src="https://i.imgur.com/rA7t3Av.png"> 
</li>
<li>Deactivating the Virtual Environment. 
The following command will deactivate the current environment &#39;env&#39; and will change to &#39;base&#39;.
<code>conda deactivate</code> 
</li>
</ol>
<ol>
<li>Removing the Virtual Environment. 
The following command removes the &#39;myenv&#39; Virtual Environment with all its packages at the same time.
<code>conda env remove -n myenv</code>
<img src="https://i.imgur.com/fxqSU5N.png">
As you can see after listing with <code>&#39;conda env list&#39;</code>, only two Virtual Environments are shown.
<img src="https://i.imgur.com/5t6HSFx.png"></li>
</ol>
<h2 id="anaconda-navigator">Anaconda Navigator</h2>
<ol>
<li>Press the &quot;Windows&quot; icon in the lower corner of the screen to open the &quot;Search&quot; box. Type &quot;Anaconda Navigator&quot; and then hit &quot;Enter&quot; to open it.</li>
<li>Move to &quot;Environments,&quot; where two virtual environments are shown.&#39; base&#39; is the default, whereas &#39;env&#39; is the previously created Virtual Environment.
<img src="https://i.imgur.com/PIJCvqP.png"> 
</li>
<li>Click &quot;Create&quot; and Fill up the required information, as shown below, to create a new Virtual Environment called &quot;new-env.&quot;
<img src="https://i.imgur.com/sHUpjDk.png"> 
</li>
<li>Move to the &quot;new-env&quot; and select &quot;All&quot; to install the required package, i.e., numpy in our case.
<img src="https://i.imgur.com/wRwduLg.png"> </li>
<li>Select &#39;new-env&#39; at the home directory so that launching an application will be specific to that particular virtual environment.
<img src="https://i.imgur.com/jHGp0Jq.png"> </li>
</ol>
<h2 id="conclusion">Conclusion</h2>
Congratulations on finishing the tutorial! 
You&#39;ve successfully learned about the Virtual Environment and creation through Pipenv and Anaconda. 
You can look over to the following courses created by Anaconda in DataCamp platform to learn more: 
<ul>
<li><a href="https://www.datacamp.com/courses/building-and-distributing-packages-with-conda">Conda for Building &amp; Distributing Packages</a></li> 
<li><a href="https://www.datacamp.com/courses/conda-essentials">Conda Essentials</a></li></ul> 
References: 
<a href="https://pipenv-fork.readthedocs.io/en/latest/install.html#installing-pipenv">Installing pipenv</a>

https://www.datacamp.com/community/tutorials/virtual-environment-in-python

In this tutorial, you'll learn about the Virtual Environment and two different ways of creating it.

(Tutorial) Virtual Environment in Python

Virtual Environment in Python

If you are just getting started in Python and would like to learn more, take DataCamp&#39;s <a href="https://learn.datacamp.com/courses/introduction-to-data-science-in-python">Introduction to Data Science in Python</a> course.
<a href="https://www.datacamp.com/learn/python/"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583330891/python_3_qgciu1.png"></a>
In today&#39;s tutorial, you will be learning about a built-in Python function called <code>range()</code> function. It is a very popular and widely used function in Python, especially when you are working with predominantly <code>for</code> loops and sometimes with <code>while</code> loops. It returns a sequence of numbers and is immutable (whose value is fixed). The range function takes one or at most three arguments, namely the start and a stop value along with a step size.
Range function was introduced only in Python3, while in Python2, a similar function <code>xrange()</code> was used, and it used to return a generator object and consumed less memory. The <code>range()</code> function, on the other hand, returns a list or sequence of numbers and consumes more memory than <code>xrange()</code>.
Since the <code>range()</code> function only stores the start, stop, and step values, it consumes less amount of memory irrespective of the range it represents when compared to a list or tuple.
The <code>range()</code> function can be represented in three different ways, or you can think of them as three range parameters:
<ul>
<li>range(stop_value) : This by default considers the starting point as zero.</li>
</ul>
<ul>
<li>range(start_value, stop_value) : This generates the sequence based on the start and stop value.</li>
</ul>
<ul>
<li>range(start_value, stop_value, step_size): It generates the sequence by incrementing the start value using the step size until it reaches the stop value.</li>
</ul>
<center>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583346610/range2_kpyiuy.png" />
</center> 

Let&#39;s first check the type of the <code>range()</code> function.
<pre><code class="lang-python">type(range(100))
</code></pre>
<pre><code>range
</code></pre>Let&#39;s start with a simple example of printing a sequence of ten numbers, which will cover your first range parameter.
<ul>
<li>To achieve this, you will be just passing in the stop value. Since Python works on zero-based indexing, hence, the sequence will start with zero and stop at the specified number, i.e., $n-1$, where $n$ is the specified number in the range function.</li>
</ul>
<pre><code class="lang-python">range(10) #it should return a lower and an upper bound value.
</code></pre>
<pre><code>range(0, 10)
</code></pre><pre><code class="lang-python">for seq in range(10):
 print(seq)
</code></pre>
<pre><code>0
1
2
3
4
5
6
7
8
9
</code></pre>As expected, the above cell returns a sequence of numbers starting with $0$ and ending at $9$.
You could also use the range function as an argument to a list in which case it would result in a list of numbers with a length equal to the stop value as shown below:
<pre><code class="lang-python">list(range(10))
</code></pre>
<pre><code>[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</code></pre><pre><code class="lang-python">len(list(range(10)))
</code></pre>
<pre><code>10
</code></pre><ul>
<li>Next, let&#39;s look at the second way of working with the range function. Here you will specify both start and the stop value.</li>
</ul>
<pre><code class="lang-python">range(5,10)
</code></pre>
<pre><code>range(5, 10)
</code></pre><pre><code class="lang-python">for seq in range(5,10):
 print(seq)
</code></pre>
<pre><code>5
6
7
8
9
</code></pre>Similarly, you can use the <code>range</code> function to print the negative integer values as well.
<pre><code class="lang-python">for seq in range(-5,0):
 print(seq)
</code></pre>
<pre><code>-5
-4
-3
-2
-1
</code></pre><pre><code class="lang-python">list(range(10,20))
</code></pre>
<pre><code>[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
</code></pre><ul>
<li>Let&#39;s now add the third parameter, i.e., the step size to the range function, and find out how it affects the output. You will specify the start point as 50, the end/stop value as 1000 with a step size of 100. The below range function should output a sequence starting from 50 incrementing with a step of 100.</li>
</ul>
<pre><code class="lang-python">range(50,1000,100)
</code></pre>
<pre><code>range(50, 1000, 100)
</code></pre>You will notice that it will print all even numbers.
<pre><code class="lang-python">for seq in range(50,1000,100):
 print(seq)
</code></pre>
<pre><code>50
150
250
350
450
550
650
750
850
950
</code></pre>It is important to note that the <code>range()</code> function can only work when the specified value is an integer or a whole number. It does not support the float data type and the string data type. However, you can pass in both positive and negative integer values to it.
Let&#39;s see what happens when you try to pass float values.
<pre><code class="lang-python">for seq in range(0.2,2.4):
 print(seq)
</code></pre>
<pre><code>---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

&lt;ipython-input-32-4d2f304928d0&gt; in &lt;module&gt;
----&gt; 1 for seq in range(0.2,2.4):
 2 print(seq)


TypeError: &#39;float&#39; object cannot be interpreted as an integer
</code></pre><ul>
<li>You would have scratched your head at least once while trying to reverse a linked list of integer values in C language. However, in python, it can be achieved with the range function with just interchanging the start and stop along with adding a negative step size.
 Isn&#39;t that so simple? Let&#39;s find out!
</li>
</ul>
<pre><code class="lang-python">for seq in range(100,10,-10):
 print(seq)
</code></pre>
<pre><code>100
90
80
70
60
50
40
30
20
</code></pre>Say you have a list of integer values, and you would like to find the sum of the list, but using the <code>range()</code> function. Let&#39;s find out it can be done.
First, you will define the list consisting of integer values. Then initialize a counter in which you will store the value each time you iterate over the list and also add the current list value with the old count value.
To access the elements from the list, you will apply the range function on the <code>length</code> of the list and then access the list elements bypassing the index <code>i</code> which will start from zero and stop at the length of the list.
<pre><code class="lang-python">list1 = [2,4,6,8,10,12,14,16,18,20]
count = 0

for i in range(len(list1)):
 count = count + list1[i]
 print(count)
print(&#39;sum of the list:&#39;, count)
</code></pre>
<pre><code>2
6
12
20
30
42
56
72
90
110
sum of the list: 110
</code></pre>You could also concatenate two or more range functions using the <code>itertools</code> package class called <code>chain</code>. And not just the <code>range</code> function, you could even concatenate list, tuples, etc. Remember that <code>chain</code> method returns a generator object, and to access the elements from that generator object, you can either use a <code>for</code> loop or use <code>list</code> and pass the generator object as an argument to it.
<pre><code class="lang-python">from itertools import chain

a1 = range(10,0,-2)
a2 = range(30,20,-2)
a3 = range(50,40,-2)

final = chain(a1,a2,a3)

print(final) #generator object
</code></pre>
<pre><code>&lt;itertools.chain object at 0x107155490&gt;
</code></pre><pre><code class="lang-python">print(list(final))
</code></pre>
<pre><code>[10, 8, 6, 4, 2, 30, 28, 26, 24, 22, 50, 48, 46, 44, 42]
</code></pre>You can apply equality comparisons between range functions. Given two range functions, if they represent the same sequence of values, then they are considered to be equal. Having said that, two equal range functions don&#39;t need to have the same start, stop, and step attributes.
Let&#39;s understand it with an example.
<pre><code class="lang-python">list(range(0, 10, 3))
</code></pre>
<pre><code>[0, 3, 6, 9]
</code></pre><pre><code class="lang-python">list(range(0, 11, 3))
</code></pre>
<pre><code>[0, 3, 6, 9]
</code></pre><pre><code class="lang-python">range(0, 10, 3) == range(0, 11, 3)
</code></pre>
<pre><code>True
</code></pre><pre><code class="lang-python">range(0, 10, 3) == range(0, 11, 2)
</code></pre>
<pre><code>False
</code></pre>As you can observe from the above outputs, even though the parameters of the range function are different, they are still considered to be equal since the sequence of both the functions is the same. While in the second example, changing the step size makes the comparison False.
<h2 id="conclusion">Conclusion</h2>
Congratulations on finishing the tutorial.
You might want to tinker around a bit with the Range function and find out a way to customize it for accepting data types other than just integers.
Please feel free to ask any questions related to this tutorial in the comments section below.
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/intro-to-python-for-data-science">Introduction to Data Science in Python</a> course.

https://www.datacamp.com/community/tutorials/python-range-function

Learn about the Python Range() function and its capabilities with the help of examples.

Learn about the PYTHON Range() function and its CAPABILITIES with the help of examples.

(Tutorial) Python Range() Function

Python Range() Function

If you are just getting started in Python and would like to learn more, take DataCamp&#39;s <a target=“_blank” href="https://learn.datacamp.com/courses/introduction-to-data-science-in-python">Introduction to Data Science in Python</a> course.
<center>
<a target=“_blank” href="https://www.datacamp.com/learn/python/"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582839819/python_4_t5pp5t.png" /></a>
</center> 

A lot of you, while reading this tutorial, might think that there is nothing undiscovered about a simple <a target=“_blank” href="https://www.datacamp.com/learn/python/">Python</a> Print function since you all would have started learning Python with the evergreen example of printing <code>Hello, World!</code>. It&#39;s also true that Python or, for that matter, any programming language, the Print function is the most basic and the baby step that you take while learning a particular language. However, while learning a programming language, you sometimes tend to focus on more advanced topics and many times forget the intricacies or capabilities of a simple function that you might almost always use.
The focus of today&#39;s tutorial will be entirely on Python&#39;s Print function; you will learn about the most underestimated function.
Let&#39;s begin this tutorial by printing the <code>Hello, World!</code> example.
<pre><code class="lang-python">print(&quot;Hello, World!&quot;)
</code></pre>
<pre><code>Hello, World!
</code></pre>Unlike <code>Python2</code>, which did not require you to put a parenthesis, in <code>Python3</code>, parenthesis is a must else it will raise a syntax error as shown below.
<pre><code class="lang-python">print &quot;Hello, World!&quot;
</code></pre>
<pre><code> File &quot;&lt;ipython-input-6-a1fcabcd869c&gt;&quot;, line 1
 print &quot;Hello, World!&quot;
 ^
SyntaxError: Missing parentheses in call to &#39;print&#39;. Did you mean print(&quot;Hello, World!&quot;)?
</code></pre>From the above output, you can conclude that in Python3, <code>print()</code> is not a statement but a function.
Having said that, let&#39;s check the <code>type/class</code> of the <code>print()</code> function.
<pre><code class="lang-python">type(print)
</code></pre>
<pre><code>builtin_function_or_method
</code></pre>It returns <code>builtin_function_or_method</code>, which means it is a predefined or a builtin <code>Python Function</code>.
Now let&#39;s say you want to add a new line or a vertical space between the below two outputs, to achieve this you can simply call the <code>print()</code> function without passing any argument in it.
<pre><code class="lang-python">print(&quot;Hello, World!&quot;);print(&quot;Hello, World!&quot;)
</code></pre>
<pre><code>Hello, World!
Hello, World!
</code></pre><pre><code class="lang-python">print(&quot;Hello, World!&quot;)
print()
print(&quot;Hello, World!&quot;)
</code></pre>
<pre><code>Hello, World!

Hello, World!
</code></pre>Let&#39;s look at the syntax of the <code>print()</code> function.
print(value, ..., sep=&#39; &#39;, end=&#39;\n&#39;, file=sys.stdout, flush=False)
As you know by now, the print function Prints the values to a stream, or to sys.stdout by default. The sys.stdout or system standard output means the print function will print the output on the screen, and it can even be changed to stdin or stderr.
<h4 id="optional-keyword-arguments-">Optional keyword arguments:</h4>
<ul>
<li><code>sep</code>: It can be a string which you would like to insert between values, defaults to space.
 Let&#39;s put a list of words inside the print function and separate them with a new line. Remember, by default; the separator adds a blank space between each word.
</li>
</ul>
<pre><code class="lang-python">print(&#39;datacamp&#39;,&#39;tutorial&#39;,&#39;on&#39;,&#39;python&#39;,&#39;print&#39;,&#39;function&#39;)
</code></pre>
<pre><code>datacamp tutorial on python print function
</code></pre><pre><code class="lang-python">print(&#39;datacamp&#39;,&#39;tutorial&#39;,&#39;on&#39;,&#39;python&#39;,&#39;print&#39;,&#39;function&#39;,sep=&#39;\n&#39;) #`\n` will put each word in a new line
</code></pre>
<pre><code>datacamp
tutorial
on
python
print
function
</code></pre>Similarly, you can separate them with a comma, or add two <code>\n</code> which will add an empty line in between or even add a plus $(+)$ sign.
<pre><code class="lang-python">print(&#39;datacamp&#39;,&#39;tutorial&#39;,&#39;on&#39;,&#39;python&#39;,&#39;print&#39;,&#39;function&#39;,sep=&#39;,&#39;)
</code></pre>
<pre><code>datacamp,tutorial,on,python,print,function
</code></pre><pre><code class="lang-python">print(&#39;datacamp&#39;,&#39;tutorial&#39;,&#39;on&#39;,&#39;python&#39;,&#39;print&#39;,&#39;function&#39;,sep=&#39;\n\n&#39;)
</code></pre>
<pre><code>datacamp

tutorial

on

python

print

function
</code></pre><pre><code class="lang-python">print(&#39;datacamp&#39;,&#39;tutorial&#39;,&#39;on&#39;,&#39;python&#39;,&#39;print&#39;,&#39;function&#39;,sep=&#39;,+&#39;)
</code></pre>
<pre><code>datacamp,+tutorial,+on,+python,+print,+function
</code></pre>Before you jump on to the next argument, i.e., <code>end</code>, remember that you can also pass in a variable to the print function. To understand this, let&#39;s take an example by defining a list of integers and pass it to the print function. You would expect it to print the list of integers.
<pre><code class="lang-python">int_list = [1,2,3,4,5,6]
print(int_list)
</code></pre>
<pre><code>[1, 2, 3, 4, 5, 6]
</code></pre><ul>
<li><code>end</code>: It is a string appended after the last value, defaults to a newline. It allows the programmer to define a custom ending character for each print call other than the default newline or <code>\n</code>.
Let&#39;s say you have two strings and you want to join them together with space, all you would need to do is in the print function of the first string <code>str1</code> add <code>end</code> argument with quotes, and you can expect the two strings to be joined by a space.
</li>
</ul>
<pre><code class="lang-python">str1 = &#39;datacamp tutorial on&#39;
str2 = &#39;python print function&#39;
</code></pre>
<pre><code class="lang-python">print(str1)
print(str2)
</code></pre>
<pre><code>datacamp tutorial on
python print function
</code></pre><pre><code class="lang-python">print(str1,end=&#39; &#39;)
print(str2)
</code></pre>
<pre><code>datacamp tutorial on python print function
</code></pre>Let&#39;s take another example where you have a function whose job is to print all values within a list on the same line. You could achieve this with the <code>end</code> argument, as shown below:
<pre><code class="lang-python">def value(items):
 for item in items:
 print(item, end=&#39; &#39;)
</code></pre>
<pre><code class="lang-python">value([1,2,3,4])
</code></pre>
<pre><code>1 2 3 4
</code></pre><ul>
<li><code>file</code>: A file-like object (stream); defaults to the current sys.stdout. Here you can mention the file in which you would like to write or append the output of the print function.
 By using the file argument, you can store the output of the print function to a file in various formats like <code>.csv</code>, <code>.txt</code>, etc. Let&#39;s understand this by taking an example wherein you iterate over each element of the list. It is saved in a text file. To accomplish this, first, you will open a text file in an <code>append</code> state in which you will be saving the output of the print statement. Next, you will define the function whose output will be appended in the text file.
</li>
</ul>
<pre><code class="lang-python">file = open(&#39;print.txt&#39;,&#39;a+&#39;)
</code></pre>
<pre><code class="lang-python">def value(items):
 for item in items:
 print(item, file=file)
 file.close() # close the file ones the function execution completes.
</code></pre>
<pre><code class="lang-python">value([1,2,3,4,5,6,7,8,9,10])
</code></pre>
Once the above function execution completes, you should see a file named <code>print.txt</code> in your current directory. Let&#39;s open it and see its contents.
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582839980/print2_las5q5.png" />
From the above output, it is clear that you can even save the output to files and not just print the output on the terminal or within the notebook.
<ul>
<li><code>flush</code>: It determines whether to forcibly flush the stream. By default, it is set to False.
Typically, output to a file or the console is buffered, with text output at least until you print a newline (<a href="https://stackoverflow.com/questions/15608229/what-does-prints-flush-do">Source</a>). Buffer means that the output is stored in some kind of a register where the output resides before it is ready to be stored or the file is finally closed. The job of the flush is to make sure that the output, which is being buffered, goes to the destination safely.
</li>
</ul>
<pre><code class="lang-python">import time
print(&#39;Please enter your email-id : &#39;, end=&#39; &#39;)
#print(&#39;Please enter your email-id : &#39;, end=&#39; &#39;, flush=True) #run this to see the difference and comment out the above line of code.
time.sleep(5)
</code></pre>
<pre><code>Please enter your email-id : 
</code></pre>If you run the above lines of code in the terminal, you will notice that the prompt string does not show up until the sleep timer ends and the program exits (<a href="https://stackoverflow.com/questions/15608229/what-does-prints-flush-do">Source</a>). However, if you add <code>flush=True</code> in the print function, you will see the prompt, and then you will have to wait for 5 seconds for the program to finish.
Somehow the Jupyter Notebook or Jupyter Lab takes care of it and shows the prompt before the 5 seconds timer, so if you want to test this functionality of print, make sure to run it in command line terminal and not on the jupyter notebook.
<a id='inp'></a>
Let&#39;s now see how you can make use of the print function to take input from the user in the jupyter notebook. For this, you will use python&#39;s builtin function <code>input()</code>.
<pre><code class="lang-python">tutorial_topic = input()
print(&quot;The topic of today&#39;s tutorial is: &quot;, end=&#39;&#39;)
print(tutorial_topic)
</code></pre>
<pre><code> Print Function


The topic of today&#39;s tutorial is: Print Function
</code></pre>As soon as you run the above cell, you should see an output as shown below:
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582839980/print3_cuub0l.png" />
<a href="#inp">Here</a> you defined an optional named argument <code>end</code> that you learned before, which concatenates the static statement inside print statement with the user input.
Let&#39;s see some cooler ways of printing variable values inside the print function.
<ul>
<li>To display a variable&#39;s value along with a predefined string, all you need to do is add a comma in between the two. Here the position of the predefined string and the variable does not matter.</li>
</ul>
<pre><code class="lang-python">a = 2
b = &quot;Datacamp&quot;
print(a,&quot;is an integer while&quot;,b,&quot;is a string.&quot;)
</code></pre>
<pre><code>2 is an integer while Datacamp is a string.
</code></pre><ul>
<li>You can make use of the <code>format</code> argument wherein you can pass as many variables as you want to print. When you pass the variables in the format function, you need to specify the index numbers (order in which they are placed inside the format argument) in the predefined string.
 So this print function will now act as a template for you.
 Another thing to remember is that here the index numbers are represented with a curly bracket <code>{}</code> representing a placeholder.
Let&#39;s understand it with the below example:
</li>
</ul>
<pre><code class="lang-python">a = 2
b = &quot;Datacamp&quot;
print(&quot;{0} is an integer while {1} is a string.&quot;.format(a,b))
</code></pre>
<pre><code>2 is an integer while Datacamp is a string.
</code></pre>If you put the index number of the second variable at both places, as expected, it will print the same values, in this case, <code>b</code> variable for both.
<pre><code class="lang-python">print(&quot;{1} is an integer while {1} is a string.&quot;.format(a,b))
</code></pre>
<pre><code>Datacamp is an integer while Datacamp is a string.
</code></pre><ul>
<li>Similar to a <code>format</code> argument where your print function acts as a template, you have a percentage (%) sign that you can use to print the values of the variables.
Like format argument, this also has a concept of placeholders. However, unlike the <code>format</code> function where you pass in just the index numbers, in this, you also need to specify the datatype the placeholder should expect.
<ul>
<li>%d is used as a placeholder for numeric or decimal values.</li>
<li>%s is used as a placeholder for strings.</li>
</ul>
</li>
</ul>
<pre><code class="lang-python">a = 2
b = &quot;Datacamp&quot;
print(&quot;%d is an integer while %s is a string.&quot;%(a,b))
</code></pre>
<pre><code>2 is an integer while Datacamp is a string.
</code></pre>Let&#39;s see what happens if you specify <code>%s</code> for the variable <code>a</code> which is an integer.
<pre><code class="lang-python">print(&quot;%s is an integer while %s is a string.&quot;%(a,b))
</code></pre>
<pre><code>2 is an integer while Datacamp is a string.
</code></pre>As you can see from the above example, it still works. The reason is that the <code>Print</code> function implicitly performed <code>typecasting</code> and converted the integer to a string. However, the opposite is not true. It will fail to convert a string to an integer and will result in a <code>TypeError</code>.
Let&#39;s find out.
<pre><code class="lang-python">print(&quot;%d is an integer while %d is a string.&quot;%(a,b))
</code></pre>
<pre><code>---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

&lt;ipython-input-121-68c55041ecfe&gt; in &lt;module&gt;
----&gt; 1 print(&quot;%d is an integer while %d is a string.&quot;%(a,b))


TypeError: %d format: a number is required, not str
</code></pre><h2 id="conclusion">Conclusion</h2>
Congratulations on finishing the tutorial.
This tutorial was a good starting point for beginners who aspire to become proficient in Python. You might want to play around with the Print function a bit more and explore a few more functionalities of it that might have been missed out in this tutorial.
Please feel free to ask any questions related to this tutorial in the comments section below.
If you are just getting started in Python and would like to learn more, take DataCamp&#39;s <a target=“_blank” href="https://learn.datacamp.com/courses/introduction-to-data-science-in-python">Introduction to Data Science in Python</a> course.

https://www.datacamp.com/community/tutorials/python-print-function

Learn how you can leverage the capability of a simple Python Print function in various ways with the help of examples.

Learn how you can LEVERAGE the capability of a simple PYTHON Print function in various ways with the help of EXAMPLES.

(Tutorial) Python Print() Function

Python Print() Function

https://www.datacamp.com/community/tutorials/python-descriptors

Learn what Python Descriptors are, when you should use them, and why you should use them. 

(Tutorial) Python Descriptors

Python Descriptors

If you would like to learn about SQL from basic to an advanced level, take DataCamp&#39;s <a href="https://www.datacamp.com/tracks/sql-fundamentals">SQL Fundamentals</a> skill track.
<h2 id="introduction">Introduction</h2>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234330/sql1_txc0vs.png" /></center>

SQL stands for <code>Structured Query Language</code>. As per Wikipedia, SQL is a domain-specific language used in programming and designed for managing data held in a relational database management system (RDBMS), or for stream processing in a relational data stream management system (RDSMS). It is particularly useful in handling structured data, i.e., data incorporating relations among entities and variables (<a href="https://en.wikipedia.org/wiki/SQL">Source</a>).
Data can be inserted, searched, updated, or deleted from the database records using SQL. SQL can be beneficial in maintaining and even optimizing the databases.
As the name suggests, SQL is capable of handling only the structured type of data, which means data that can be represented in rows and columns format like dates, numbers, and strings. On the other hand, unstructured data can be represented in the form of images, videos, speech, or text.
But what kind of information do these Databases hold?
They can hold a variety of information or maybe anything that you could think of—ranging from catalogs of product, customer information, images metadata, text data, etc.
Let&#39;s say you want to automate the process of Resume screening, and you would like to store the name, education, job experience, and application date of the candidate who has applied for an open job position. You would need a database to be designed which would store the above information related to the candidate, and to achieve this; you will need an SQL server.
In order for the information to be easily accessible and understandable, you need database management systems or relational database management system. DBMS can be helpful in a variety of ways, like sorting information or linking databases to each other, provide reports about any updates in the database, and even manage administrative access to the database.
Some of the most popular SQL databases are:
<ul>
<li><code>MySQL</code>: It is the most popular open-source relational database management system. Just to name a few, MySQL is currently being used by Facebook, Youtube, and Twitter. Since it&#39;s open-source, it comes without any cost associated with it.
</li>
<li><code>Oracle Database</code>: It is a multi-model DBMS developed by Oracle and is written in the C++ language. It is widely used for running online transaction processing like bank payment server websites. Though being costly, it is very reliable. To handle unstructured data, Oracle has also released an Oracle NoSQL database.
</li>
<li><code>MS SQL</code>: An RDBMS developed by Microsoft. It supports both structured (SQL) and unstructured (NoSQL) data. Its primary function is to store and retrieve data based on the requests it receives from other software-like applications. It is fast and stable and works well with other Microsoft based products.
</li>
<li><code>Microsoft Azure</code>: It is a cloud computing service created by Microsoft. Its primary functionalities are building, testing, deploying, and managing applications and services which are managed by Microsoft owned data centers. It provides software as a service (SaaS), platform as a service (PaaS) and infrastructure as a service (IaaS)(<a href="https://www.juniper.net/documentation/en_US/vsrx/topics/concept/security-vsrx-azure-overview.html">Source</a>). It has support for various programming languages. It is considered to give a tough competition to Amazon Web Services (AWS) and Google Cloud Platform (GCP).
</li>
</ul>
Few other popular SQL databases are <code>IBM DB2</code>, <code>MariaDB</code>, <code>Sybase</code>, and <code>PostgreSQL</code>.
In today&#39;s tutorial, you will learn to install Microsoft SQL (MS SQL). So without any further ado, let&#39;s get started!
<h3 id="installing-ms-sql-on-windows">Installing MS SQL on Windows</h3>
<ul>
<li>Firstly you have to search on google <code>Microsoft SQL server download</code> and click on the very first link that it shows as shown below. Make sure it is a Microsoft website and not any other third-party site.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234330/sql2_gl4va2.png" /></center>

<ul>
<li>Then scroll down and look for <code>Developer</code> edition, click <code>Download Now</code>, and save the file. The developer edition is a full version and comes packaged with a fully featured free edition specially designed for developers.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234330/sql3_f2s66o.png" /></center>

<ul>
<li>Once the download is successful, go to the downloaded folder and look for the <code>SQLServer2017-SSEI-Dev.exe</code> file. Double click on that file, and you should see <code>Getting things ready</code>, which means everything is going smoothly.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234330/sql4_z1lj14.png" /></center>

<ul>
<li>After that, it will show you three options <code>Basic</code>, <code>Custom</code>, and <code>Download Media</code>. You need to select the second option, which is <code>Custom</code>.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234331/sql5_viij80.png" /></center>

<ul>
<li>Then you will be asked where you would like your MS SQL installation files to reside, choose accordingly, and click on <code>Install</code>. Make sure you have good internet connectivity. In the meantime, feel free to take a short nap since it will take some time to install.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234330/sql6_lpqizh.png" /></center>

<ul>
<li>Once the download is complete, you shall see download success. It will take you to the next steps that are necessary. A new window with the <code>SQL Server Installation Center</code> will open, which will have planning, installation, maintenance, etc. You need to click on <code>installation</code> and then on the right side of the panel you will find multiple options, you need to select <code>New SQL Server stand-alone installation or add features to existing installation</code>.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234331/sql7_ofg1mw.png" /></center>

<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234331/sql8_hydqxe.png" /></center>

<ul>
<li>Then it will open the <code>SQL Server 2017 setup</code> window in which, by default, the checkbox with <code>specify a free edition</code> to Developer would be selected. All you need to do is click next and accept the license terms and again click on next. It will install the setup files and move to the next step, which is <code>install rules</code>. You might get a warning of <code>windows firewall</code>, which you can safely ignore.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234331/sql9_hrve93.png" /></center>

<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234332/sql10_qxx8pq.png" /></center>

<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234331/sql11_m2v2wh.png" /></center>


<ul>
<li>Then you will be directed to the <code>Feature Selection</code> setup in which you will find a lot of options to select from, like instance features, database engine services, machine learning services, etc. You need to select the <code>Database engine services</code> and click next.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234331/sql12_okx4n0.png" /></center>

<ul>
<li>In the <code>instance configuration</code>, specify an instance name that will be later used to connect to the SQL server. Let&#39;s name it <code>Datacamp_Sql</code> and click next. You can skip the <code>Server configuration</code> and directly move on to the <code>database engine configuration</code>.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234330/sql13_jijtpt.png" /></center>

<ul>
<li>In database engine configuration, select <code>mix mode</code> as the authentication mode, specify the password, i.e., <code>datacamp@1234</code> and click on <code>add current user</code>. Remember that this password will be used with the instance name that you had created in the previous step. Finally, click on <code>install</code>.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234331/sql14_g9x79e.png" /></center>

<ul>
<li>Now you will be in the installation progress mode, wait for a while, and let the installation complete. Once the installation is complete, you will receive an <code>Installation successful</code> in the detail box. Feel free to close the SQL server setup window.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234331/sql15_y6ta5f.png" /></center>

<ul>
<li>Now coming back to the SQL Server installation center, you need to install the <code>SQL server management studio</code>, which provides you a graphical user interface (GUI) for connecting to the database, creating a database, tables, and a lot more. To install the studio, you need to click the <code>SQL server management tools</code>, which is the third option.</li>
<li>By clicking the <code>SQL server management tools</code>, you will be redirected to the Microsoft website from where you can download the SQL server management studio. It can also be downloaded from the same website from where you initially downloaded the SQL server 2019 developer edition.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234331/sql16_tzo4x8.png" /></center>

<ul>
<li>Once the installation is complete, you should see a file named <code>SSMS-Setup-ENU</code> in your downloaded folder. Double click on that file and select <code>Yes</code>. Then click on <code>Install</code>, it will take some time for it to complete again depending upon your internet connection. You might be asked to restart your system for the installation to complete. Once the setup is complete, click on close.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234331/sql17_kojzza.png" /></center>

<ul>
<li>Finally, you can close the <code>SQL server installation center</code>. Go to windows start and search for <code>Microsoft SQL Server Management Studio</code>, and you should be able to find it, once you open it the UI should look similar to one shown below:</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234331/sql18_lv6o8v.png" /></center>

<ul>
<li>It will show you a <code>connect to server</code> option with multiple parameters like Server Type, Server Name, Authentication, etc. Click on <code>server name</code> and select <code>browse for more</code> in that select <code>Database engine</code>. Once you select <code>Database Engine</code> it would show you the instance name you had created in instance configuration, click ok.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234331/sql19_kgohpp.png" /></center>

<ul>
<li>Then in the <code>Authentication</code>, select <code>SQL Server authentication</code>. It&#39;s important to note that the login will be default name i.e., <code>sa</code>, and the password will be the same as you had created in the earlier steps.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234331/sql20_cazamw.png" /></center>

<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234332/sql21_ijce5q.png" /></center>

<ul>
<li>As a final step, just click on <code>Connect</code>. Once connected, you should see the <code>Datacamp_SQL</code> server that you had created listed on the <code>object explorer</code> panel, which means that you have successfully established a connection with your local SQL server. And you are all set to create a database, add, delete and insert in it.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1582234332/sql22_qxes1d.png" /></center>

Awesome, so you were successful in installing SQL Server. Enjoy learning SQL!
<h2 id="conclusion">Conclusion</h2>
Congratulations on finishing the tutorial.
This tutorial should take you one step closer to learning SQL in a more practical sense since your environment is set up now.
Please feel free to ask any questions related to this tutorial in the comments section below.
If you would like to learn about SQL from basic to an advanced level, take DataCamp&#39;s <a href="https://www.datacamp.com/tracks/sql-fundamentals">SQL Fundamentals</a> skill track.

https://www.datacamp.com/community/tutorials/how-to-install-sql-server

In this tutorial, you will learn how to install SQL Server on a Windows operating system with a brief introduction to SQL in general.

(Tutorial) How to Install SQL Server

How to Install SQL Server

<h2 id="pdf-documents">PDF Documents</h2>
PDF is a Portable Document Format where it contains texts, images, charts, etc. which is different from plain text files. It is a file that contains the &#39;.pdf.&#39; extension and was invented by Adobe. This type of file is independent of any platforms like software, hardware, and operating systems.
<h2 id="steps-to-install-package-">Steps to Install-Package:</h2>
<ol>
<li>You need to install a package named &quot;pypdf2&quot; which can handle the file with &#39;.pdf&#39; extension.
<img src = "https://i.imgur.com/vzhJM3Q.png" />
</li>
<li>You can see the &#39;pypdf2&#39; package is installed and shown below.
<img src ="https://i.imgur.com/wvEAm3B.png">
</li>
</ol>
<h2 id="reading-pdf-documents-and-extracting-a-data">Reading PDF documents and Extracting a data</h2>
You will be extracting only the text from the pdf file as PyPDF2 has a limitation when it comes to extracting the rich media content. The logos, pictures, etc. couldn&#39;t be extracted from it — the following pdf file needs to be download to work with this tutorial. 
<a href = "https://drive.google.com/file/d/1jEuyqKKNqeq--SuERYBlurM_XGy1z5He/view?usp=sharing">Download Pdf file</a>
<img src = "https://i.imgur.com/IoNecb9.png" />
The &#39;import&#39; statement in the code above gets the PyPDF2 module. You need to use &#39;open(&#39;pdfFileName&#39; , &#39;openingMode&#39;)&#39;where the &#39;pdfFilename&#39; is &#39;test.pdf&#39;, and the &#39;openingMode&#39; is &#39;rb&#39; which is the reading only in binary format.
<img src = "https://i.imgur.com/o0LPBve.png" />
The PyPDF2 has a method as &#39;PdfFileReader&#39;, which takes the newly created object &#39;pdfFileObject&#39;.You can now access the attribute named &#39;numPages&#39; from &#39;pdfFileObject&#39;, which gives a total number of the pages.
<img src= "https://i.imgur.com/YBL3JEV.png">
The above output is 1.Since; you can see the pdf file is of only one page.
<img src="https://i.imgur.com/oC6TWqV.png">
You can use the &#39;getPage(0)&#39; method inside the pdfReaderObject to get the first page.The result then is stored in the &#39;firstPageObject&#39; where all the text inside that particular page can be printed out by using the &#39;extractText()&#39; method.
<img src="https://i.imgur.com/8bBFHcz.png" width =600>
The above code gives all the text from the pdf file. However, the image is not shown in the terminal, which cannot be obtained using pyPDF2.
<h2 id="merging-multiple-pdf-files-into-one-pdf">Merging multiple PDF files into one PDF</h2>
You will be merging two different pdf files into a single pdf file. The old PDF file is previous that you&#39;ve worked with, whereas a new PDF file can be downloaded from the following link: 
<a href="https://drive.google.com/file/d/1_2r_S0K6wxTjH7dsQz0yHWuKaWGL5VCD/view?usp=sharing">New PDF file</a>.
<img src="https://i.imgur.com/pIKsS1H.png">
You will be importing the PdfFileMerger module from the PyPDF2 package, which helps to merge the pdf files. The &#39;path&#39; is specified, which indicates the path for the folder where the file is located. Also, pdf files to merge are included in &#39;pdf_files&#39; in a list.
<img src="https://i.imgur.com/MNNjURT.png">
You can see the merger object is created using the help of &#39;PdfFileMerger.&#39; The looping is done for each file in a list where merging is done by passing the path and file to the &#39;append&#39; method. At last, the final output can be obtained by using &#39;merger.write()&#39; where the merged content with a new PDF filename is obtained.
<img src="https://i.imgur.com/RizZlFc.png">
The above picture indicates a &#39;merged.pdf,&#39; which consists of the content merged from &#39;test.pdf&#39; and &#39;test-1.pdf&#39;.
<h2 id="word-documents">Word Documents</h2>
The Word documents consist of the &quot;.docx&quot; extension at the end of the filename. These documents don&#39;t only contain text as in plain text files, but it includes a rich-text document. The rich-text document contains the different structures for the document, which have size, align, color, pictures, font, etc. associated with them.
It would be best if you had an application for working with the Word Documents. The popular application for Windows and Mac Operating systems is Microsoft Word, but it is a paid subscription platform. However, there is a free alternative option like &quot;LibreOffice&quot;, which is an application in Linux which comes pre-installed. The applications can be downloaded for <a href = "https://www.libreoffice.org/download/download/"> Windows and Mac Operating systems.</a> This tutorial will use Microsoft Word in the Windows Operating system.
<h2 id="steps-to-install-package-">Steps to Install-Package:</h2>
<ol>
<li>You need to install a package named &quot;python-docx&quot; which can handle the word documents of the &#39;.docx&#39; extension.
<img src = "https://i.imgur.com/IdTL1nH.png" />
</li>
<li>You can see the &#39;python-docx&#39; package installed and shown below.
<img src ="https://i.imgur.com/8YaJGpn.png">
</li>
</ol>
You can code along in the interactive shell provided by Python, but it is preferred to use the Text Editor. So, Sublime Text is used for the coding part of this tutorial.
<h2 id="writing-a-word-documents">Writing a Word Documents</h2>
<img src="https://i.imgur.com/LfliFyr.png" width = 600 height = 600>
You can see above the &#39;document&#39; module is imported from the &#39;docx&#39; package in the first line. The code in the second line produces a new word document through the help of the Document object.The filename is saved as &#39;first.docx&#39; using the &#39;document.save()&#39;.
<h3 id="add-a-heading">Add a heading</h3>
<img src="https://i.imgur.com/hLsCRBu.png" width = 600 height = 600>
The above code contains a &#39;Document()&#39;opens a new file and &#39;document.save(&#39;addHeader.docx&#39;)&#39; is used to create a newly edited docx file. You can add the heading through method &#39;add_heading(&#39;text,&#39; level=number),&#39; which takes the text as a heading, and the heading level from starts from 0 to 4.
<img src="https://i.imgur.com/Uxp7c1B.png" width = 600 height = 600>
The above code gives the output as a newly created &#39;addedHeader.docx&#39; file where level 0 makes a headline with the horizontal line below the text, whereas the heading level 1 is the main heading. Similarly, the other headings are sub-heading with their&#39;s font-sizes in decreasing order.
<h3 id="add-a-paragraph">Add a Paragraph</h3>
<img src="https://i.imgur.com/CuSBhGJ.png" width = 600 height = 600>
The above code contains a &#39;Document()&#39; which opens a new document file and &#39;document.save(&#39;addParagraph.docx&#39;)&#39; is used to create a newly edited docx file. You can add the heading through method &#39;add_paragraph(&#39;text,&#39; style=&#39;required_style&#39;)&#39; which takes the text and also &#39;style&#39; is an optional argument where &#39;List Number&#39; and &#39;List Bullet&#39; can be used.
<img src="https://i.imgur.com/wcIur4j.png" width = 700 height = 700>
The above code gives the output as a newly created &#39;addedParagraph.docx&#39; file where there is a simple paragraph at first line. Similarly, there is a heading, and below it contains an ordered list containing an item with number 1 and 2.Below that there is another heading containing a two item in an unordered bulleted list.
<h3 id="add-a-picture">Add a Picture</h3>
<img src="https://i.imgur.com/BXLgbIr.png" width = 600 height = 600>
The above code contains a &#39;Document(),&#39; which creates a new document file, and &#39;document.save(&#39;addPicture.docx&#39;)&#39; is used to create a newly edited docx file. You can add the image by using &#39;add_picture()&#39; which contains the first parameter as &#39;cat-1.jpeg&#39; is the path for the cat image. The widths and heights are the optional parameters that will be default as &#39;72 dp,&#39; but we have used &#39;Inches&#39; for our purpose.
<img src="https://i.imgur.com/AAalXfY.png" width = 600 height = 600>
The above code gives the output as a newly created &#39;addedPicture.docx&#39; file, which contains a cat image where there are 1.25 inches of width and height in the image.
<h2 id="reading-a-word-documents">Reading a Word Documents</h2>
You&#39;ll now read a sample word document from Python, and it can be found in: 
<a href = "https://docs.google.com/document/d/13oX775JlQRweV02ZpY0_N35eC0CcWkE0fHK4CHaBLLc/edit?usp=sharing">Download Sample</a>.
<img src="https://i.imgur.com/0UbmZav.png" width =600 height =600 />
The first line in the code imports the Document from the &#39;docx&#39; module, which is used to pass the required document file and to create an object .&#39;obtainText&#39; is a function that receives the file &#39;fullText.docx.&#39; The looping is done for each paragraph, which is accessed by &#39;document.paragraphs&#39; and is inserted into an empty list using the &#39;append&#39; method. Finally, the function returns a list of paragraphs ending with a new line.
<img src="https://i.imgur.com/TRUWenI.png" width = 600 height = 600 />
The above output gives the plain text without any style, color, etc. which is not a rich text document.
<h2 id="congratulations">Congratulations</h2>
Congratulation, you&#39;ve finished reading this tutorial.
If you would like to learn more about importing data in Python, try DataCamp&#39;s <a href="https://www.datacamp.com/courses/introduction-to-importing-data-in-python">Introduction to Importing Data in Python</a> course.
You can also look at the following resources to help broaden your knowledge on specific topics. 
<ol>
<li><a href="https://python-docx.readthedocs.io/en/latest/">Documentation of Python Docx</a> </li>
<li><a href = "https://pythonhosted.org/PyPDF2/">Documentation of PyPDF2</a></li>
</ol>
References: 
<a href="https://automatetheboringstuff.com/chapter13/">Automate Boring Stuff With Python: Working with Word Documents</a>

https://www.datacamp.com/community/tutorials/reading-and-editing-pdfs-and-word-documents-from-python

This tutorial will allow you to read PDF documents and merge multiple PDF files into one PDF file. It will also show how to read and write word documents from Python.

(Tutorial) Reading and Editing PDF’s and Word Documents From Python

Reading and Editing PDF’s and Word Documents From Python

https://www.datacamp.com/community/tutorials/utilities-in-r

Learn about several useful functions for data structure manipulation, nested-lists, regular expressions, and working with times and dates in the R programming language.

Learn about several useful functions for DATA structure manipulation, nested-lists, REGULAR EXPRESSIONS, and working with times and dates in the R PROGRAMMING language.

(Tutorial) Utilities in R

Utilities in R

Django is a widely used free, open-source, and high-level web development framework. It provides a lot of features to the developers &quot;out of the box,&quot; so development can be rapid. However, websites built from it are secured, scalable, and maintainable at the same time.
<h2 id="goal">Goal</h2>
The goal of this tutorial is to build a blog application where the blog content can be created and updated through an administration panel. Blog contents are displayed on the page and can be deleted if needed.Overall application provides CRUD(Create,Read,Update,Delete) functionality. 
This tutorial doesn&#39;t use any FrontEnd technologies like Javascript, CSS, etc. but focuses on basic yet essential concepts that are needed in every Django Web Development.
<h2 id="required-setup">Required Setup</h2>
<ol>
<li>Git Bash: The user of all operating systems can use it. All the Django related commands and Unix commands are done through it. For downloading the Git bash: <a href="https://git-scm.com/downloads">Click Me</a>.</li>
<li>Text-Editor: Any Text-Editor like Sublime Text or Visual Studio Code can be used. For the following project, <a href="https://www.sublimetext.com/">Sublime Text</a> is used.</li>
<li>Python 3: The latest version of Python can be downloaded in <a href="https://www.python.org/downloads/">Download Python</a>.</li>
</ol>
Note: You can easily follow along with this tutorial if you understand the basics of Python and know about loops, function, classes, etc., and some knowledge of bash or command line.
<h2 id="virtual-environment">Virtual Environment</h2>
Virtual Environment acts as dependencies to the Python-related projects. It works as a self-contained container or an isolated environment where all the Python-related packages and the required versions related to a specific project are installed. Since newer versions of Python, Django, or packages, etc. will roll out, through the help of a Virtual Environment, you can work with older versions that are specific to your project. In Summary, you can start an independent project related to Django of version 2.0, whereas another independent project related to Django of version 3.0 can be started on the same computer. 
Note: There are many ways of creating a Virtual Environment, but only one way is shown below.
<h2 id="steps-to-create-a-virtual-environment">Steps to create a Virtual Environment</h2>
<ol>
<li>You can create the new directory named &#39;project-blog&#39; by using &#39;mkdir&#39; command in your Desktop.</li>
<li>Change the directory to &#39;project-blog&#39; by using &#39;cd&#39; command.
 <img src="https://i.imgur.com/GfvSQUj.png"> 
</li>
<li>The virtual environment is created by using &#39;python -m venv env&#39;, where env is our virtual environment shown by &#39;ls&#39; command.
 <img src="https://i.imgur.com/CbBq40I.png"> 
</li>
<li>For Activating your Virtual Environment:
The Virtual Environment can be activated by using the &#39;source&#39; command where the &#39;Scripts&#39; folder needs to be enabled or activated.
 <img src="https://i.imgur.com/Gu15w7W.png"> 
The &#39;env&#39; will be shown in the parenthesis if you&#39;ve successfully activated your Virtual Environment. 
</li>
<li>Installing the required package:
You can use &#39;pip install django&#39; to install Django in your specific Virtual Environment.
 <img src="https://i.imgur.com/PgLbUsT.png"> </li>
</ol>
Note: Linux and Mac users need to use &#39;python3&#39; specifically in the command because Python of version 2 is already pre-installed in their computer. Also, It is preferable to use version 3 as of now Python will not support version 2 after the year 2020.
<h2 id="creating-a-django-project">Creating a Django Project</h2>
<ol>
<li>The first step is creating your project by using the &#39;django-admin startproject <code>project_name</code>&#39; command, where &#39;project_name&#39; is &#39;django_blog&#39; in your case. Also, it will generate a lot of files inside our newly created project, which you can research further in <a href="https://docs.djangoproject.com/en/3.0/intro/tutorial01/">Django documentation </a> if needed.
 <img src="https://i.imgur.com/abCcs9y.png"> </li>
<li>Change the directory to the newly created project using &#39;cd&#39; command and to view the created file using &#39;ls&#39; command.
 <img src="https://i.imgur.com/81EkZNS.png"> </li>
<li>You can run your project by using &#39;python manage.py runserver&#39;.
 <img src="https://i.imgur.com/zLcoMn5.png"> </li>
<li>The project can be viewed in your favorite browser (Google Chrome, Mozilla Firefox, etc.).You can come into your browser and type &#39;localhost:8000&#39; or &#39;127.0.0.1:8000&#39; in the URL, as shown below.
 <img src="https://i.imgur.com/wOA4abG.png"> 
Note: To get the same page as above, the server in the bash needs to be running in the background. Also, you can manually stop the server if needed by hitting &#39;Ctr+C&#39; in Windows/Linux and &#39;Cmd+C&#39; in Mac.</li>
</ol>
<h2 id="starting-the-new-project">Starting the new Project</h2>
For creating a new project in the Django, it&#39;s always a two-step process, which is shown below.
<ol>
<li>The first step is to create an app by using &#39;python manage.py startapp <code>app_name</code>&#39; command, where app_name is &#39;blog&#39; in your case.
In Django, there are many apps to the single project where each app serves as single and specific functionality to the particular project.
 <img src="https://i.imgur.com/sr5TjIf.png"> </li>
<li>The second step is to make our project let know about our newly created app by making changes to the &#39;django_blog/settings.py&#39; INSTALLED_APP section.
 <img src="https://i.imgur.com/fwaWBa1.png"></li>
</ol>
<h2 id="changing-in-our-models">Changing in our Models</h2>
Django uses &#39;SQLite&#39; as the default database, which is light and only used for small projects, which is fine for this project.
It uses &#39;Object Relational Mapper(ORM)&#39; which makes it really easy to work with the database. The actual database code is not written, whereas the database tables are created through the help of &#39;class&#39; keyword in &#39;models.py&#39;.
Inside &#39;blog/models.py&#39;, you need to create a new model named &#39;Post&#39;. This is a class that will become a database table afterward which currently inherits from &#39;models.Model&#39;. As in a standard blog, a certain &#39;Post&#39; contains a title, which will be a field called CharField. It is a text-based column and accepts mandatory argument as &#39;max_length&#39;, which happens to be 50 in your case. Also, there is another field named &#39;content&#39;, which is the TextField, which contains the detail text of the &#39;Post&#39; as in a standard blog.
The double underscore(&#39;str&#39;) method is defined, which overrides the field &#39;title&#39; and returns the name of actual &#39;title&#39; instead of some objects.
 <img src="https://i.imgur.com/od9GmHw.png">
<h3 id="making-a-migrations">Making a Migrations</h3>
&#39;python manage.py makemigrations&#39; is a first step process which reads the &#39;models.py&#39; after it&#39;s creation. It creates a new folder called &#39;migrations&#39; where there is a file named &#39;0001_initial.py&#39;, which are portable across the database.
 <img src="https://i.imgur.com/Ab0weiT.png">
<h3 id="migrating-to-the-database">Migrating to the database</h3>
This is the second step where &#39;python manage.py migrate&#39; reads the newly created folder &#39;migrations&#39; and creates the database, and it evolves the database when there is a change in the model.
 <img src="https://i.imgur.com/zh5hYWe.png">
<h3 id="registering-to-the-admin">Registering to the admin</h3>
Let&#39;s move to &#39;blog/admin.py&#39; and do an import of the models called &#39;Post&#39; by using &#39;from .models import Post&#39;. To register models to the admin, the command is &#39;admin.site.register(Post)&#39;.
 <img src="https://i.imgur.com/z7WQZD3.png">
<h3 id="creating-superuser-and-viewing-in-the-administration-panel">Creating SuperUser and Viewing in the Administration panel</h3>
You need to create a SuperUser before accessing the &#39;admin&#39; panel. To do so, use &#39;winpty python manage.py createsuperuser&#39;.
 <img src="https://i.imgur.com/k2JLU52.png"> 
Note: winpty is bash specific command used for communicating with Windows Console Programs. 
Run your server in the background in bash by command python manage.py runserver. Head over to the browser and type the following in the URL.
 <img src="https://i.imgur.com/ZEv8Qgv.png"> 
Fill out your details afterward, i.e., the username and password that you&#39;ve created earlier:
 <img src="https://i.imgur.com/lWGLVzw.png"> 
View your admin panel afterward with our newly created models &#39;Post&#39;.
 <img src="https://i.imgur.com/VVMr1EV.png"> 
Change the content of the &#39;Post&#39; by clicking the &#39;Add&#39; button. Fill out the information and &#39;Save&#39; the detail.
 <img src="https://i.imgur.com/To8du5O.png">
<h3 id="changing-in-views-and-urls">Changing in views and urls</h3>
Move to &#39;blog/views.py&#39; and make the changes as shown below. Add the function &#39;blog_list&#39;, which takes in the request. The query is made, which gets all the objects created using &#39;Post.objects.all()&#39; and save it to the post. There is a newly created dictionary as &#39;context&#39; where the object can be passed as key and obtained through template &#39;blog-list.html&#39;, which is done by returning the response with the help of render.
 <img src="https://i.imgur.com/XyzzrE2.png"> 
Make a new file called &#39;urls.py&#39; in &#39;django_blog/blog&#39; and add the following changes. There is relative import to the views &#39;blog_list&#39; also a &#39;urlpatterns&#39;, which is a list of the path to a specific page on the website. Currently, the <b'path' contains the empty string and name of the view.
 <img src="https://i.imgur.com/tkScSfm.png"> 
Let&#39;s move to &#39;django_blog/urls.py&#39; and import include and make a change to &#39;urlpatterns&#39;. Then add the path to your app URLs through include. Also, when users route through &#39;posts/&#39; then, it gets directed to our &#39;blog.urls.&#39;
<h3 id="making-and-changing-the-templates">Making and Changing the Templates</h3>
Let&#39;s make a templates folder that generally holds the &#39;HTML&#39; and contains their own templating language called &#39;Jinja2&#39;.The folder needs to name &#39;templates/blog/blog_list.html&#39;, which is the convention.
 <img src="https://i.imgur.com/ceM1ffK.png"> 
You can see below there is syntax related to &#39;HyperTextMarkup Language(HTML) where &#39;h1&#39; for big headline and an unordered list(ul) with list element li. Also, &#39; for&#39; loop syntax related to &#39;Jinja 2&#39; is used where an object called &#39;blog_list&#39; passed as key from &#39;blog/views.py&#39; with each element called &#39;list&#39; is iterated.
 <img src="https://i.imgur.com/dt5UOJC.png"> 
View the &#39;title&#39; named as &#39;First Post&#39; on the webpage.
 <img src="https://i.imgur.com/5wMbeRT.png"> 
Let&#39;s add another information from the admin panel the same as above and name your second post title as &#39;Second Post.&#39;
 <img src="https://i.imgur.com/JF96yQl.png"> 
After adding the information and reloading the homepage, the information will be updated.
 <img src="https://i.imgur.com/KSaxElq.png">
<h3 id="details-for-each-individual-post">Details for Each Individual post</h3>
You will be creating each individual page containing information regarding the post title, and it&#39;s content. The &#39;url&#39; will be &quot;localhost:8000/posts/&#39;id&#39;&quot; where id indicates the unique number or primary key attached to each &#39;Post&#39; given by Django itself. 
Let&#39;s create a function as &#39;blog_detail&#39; in &#39;blog/view.py&#39; , which accepts id as a parameter. Also, there is a query made for getting specific id only and saving to &#39;each_post&#39;. Similarly, as above, the information needed is passed as context to the &#39;blog_detail.html&#39;.
 <img src="https://i.imgur.com/lEc6Tcb.png"> 
The url in &#39;blog/urls.py&#39; is changed where path contains the &#39;<code>&lt;id&gt;</code>&#39;, which accepts the unique id in the integer form. Assume that the user comes to &#39;posts/&#39; only then sees all the posts, but when they to &#39;posts/1&#39;, they only see the information regarding the first created post.
 <img src="https://i.imgur.com/gOqq4xb.png"> 
Let&#39;s create a new file, &#39;blog/blog_detail.html&#39;, and make the following changes. Since blog_detail is passed as context, the &#39;title&#39; and &#39;content&#39; can be accessed using dot notation.
 <img src="https://i.imgur.com/tzSxKPm.png"> 
Head over to the URL of your browser and type the same thing to get individual posts. Since the &#39;id&#39; for the first information created is &#39;1&#39; where the second information is to be &#39;2&#39; and so on for newly created information.
 <img src="https://i.imgur.com/CyPpbm3.png">
<h3 id="deleting-the-post">Deleting the Post</h3>
Let&#39;s define the blog_delete, which takes in the request and the id. Also, query is made where &#39;Post.objects.get(id=id)&#39; gets the object with a unique id and save it to each_post. After that the &#39;each_post.delete()&#39; is called to delete the &#39;Post&#39;.Finally HttpResponseRedirect is imported from the &#39;django.http&#39; module where it is used to redirect the page to the &#39;/posts/&#39;
 <img src="https://i.imgur.com/GzPTVdH.png"> .
In the &#39;urls.py&#39; import &#39;blog_delete&#39; and path is set to &#39;&lt;id&gt;/delete&#39; where the id with delete at the end will remove that particular object or information.
 <img src="https://i.imgur.com/TX2GuFL.png"> 
Let&#39;s delete our post by typing the following thing in the &#39;urls.py&#39;.
 <img src="https://i.imgur.com/0xHgfzl.png"> 
At last, the page gets redirected to &#39;/posts&#39; when &#39;posts/1/delete/&#39; is called where only one post exists on the homepage.
 <img src="https://i.imgur.com/O8Jb9rJ.png">
<h2 id="conclusion">Conclusion</h2>
Congratulations on finishing the tutorial!
You&#39;ve learned the basics of the Django Web Development and know about the CRUD functionality. Also, for more details in a particular topic head over to the <a href="https://docs.djangoproject.com/en/3.0/">Django Documentation.</a>
References:
<ul>
<li><a href="https://www.youtube.com/watch?v=_04toQWN5-8">Just Django</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Learn/Server-side/Django/Introduction">Mozilla Django Introduction</a></li>
</ul>

https://www.datacamp.com/community/tutorials/web-development-django

Learn about the basics of web development using Django to build blog applications that have the (CRUD) Create, Read, Update, Delete functionality.

Learn about the basics of WEB DEVELOPMENT using DJANGO to build blog applications that have the (CRUD) Create, Read, Update, Delete functionality.

community

datacamp

Data Science Tutorials