Data Reshaping in R is something like arranged rows and columns in your own way to use it as per your requirements, mostly data is taken as a data frame format in R to do data processing using functions like &#39;rbind()&#39;, &#39;cbind()&#39;, etc.
In this process, you reshape or re-organize the data into rows and columns. Reshaping is re-organized data in a particular way which you need the data to process further.
<h2 id="creating-your-data">Creating your data</h2>
Let&#39;s create a random number generator and make columns to concatenate them in the data frame. Also, insert the id for later use. &#39;set.seed(123)&#39; is used for producing the random numbers where the same sample is reproduced across all the machine anyone who uses it. Three variables, colm1, colm2, colm3, are made. With the help of &#39;sample()&#39;, the value from 1 to 15 is generated, and the same value can get repeated. Also, a data frame is used to store data in the table, and id is also joined, which is a unique number.
<pre><code>set.seed(123)
N &lt;- 15
colm1 &lt;- sample(1:15, N, replace=TRUE)
colm2 &lt;- sample(1:15, N, replace=TRUE)
colm3 &lt;- sample(1:15, N, replace=TRUE)
df_Temp &lt;- data.frame(colm1, colm2,colm3)
df_Temp$id&lt;-seq(nrow(df_Temp))
df_Temp
</code></pre>The above code gives the following output where there are three columns named as &#39;colm1&#39;, &#39;colm2&#39;, &#39;colm3&#39; and consists of id from 1 to 15. The values in the respective column are filled up from 1 to 15, where some numbers are repeated, whereas some numbers may not occur.
<pre><code> colm1 colm2 colm3 id
 15 11 14 1
 15 5 3 2
 3 3 4 3
 14 11 14 4
 3 9 1 5
 10 12 11 6
 2 9 7 7
 6 9 5 8
 11 13 12 9
 5 3 15 10
 4 8 10 11
 14 10 13 12
 6 7 7 13
 9 10 9 14
 10 9 9 15
</code></pre><h3 id="cbind-function">cbind function</h3>
Usage: used to combine vectors, matrix, and data frames by columns. 
Parameters:cbind(v1,v2): v1,v2 can be vectors, matrix or data frames
Let&#39;s see the example of binding in action.
id can be selected by &#39;df_Temp[,4]&#39; whereas &#39;df_Temp[,2]&#39; selects &#39;colm2&#39; of df_Temp as below which acts as a parameter to &#39;cbind()&#39; and gets stored in &#39;cbindexample&#39; variable. Further, the column names can be changed through the help of &#39;colnames()&#39; which accepts the variable with the vectors input c to a new value, i.e. &#39;newid&#39;, &#39;new_colm2&#39;.
<pre><code>cbindexample&lt;-cbind(df_Temp[,4],df_Temp[,2])
colnames(cbindexample)&lt;- c(&#39;newid&#39;,&#39;new_colm2&#39;)
cbindexample
</code></pre>The above code gives the following output that you can bind two columns of id and column2 using &#39;cbind&#39; function to make a new data frame. Also, the column name has been changed to &#39;new_colm2&#39; whereas &#39;id&#39; changed to &#39;newid&#39;.
<pre><code>newid new_colm2
1 11
2 5
3 3
4 11
5 9
6 12
7 9
8 9
9 13
10 3
11 8
12 10
13 7
14 10
15 9
</code></pre><h3 id="rbind-function-">rbind function:</h3>
usage: rbind used to combines the vectors, matrix, or data frames by columns. 
Parameters: rbind(v1,v2):v1,v2 can be vectors, matrix or data frames.
Let&#39;s create a new vector called &#39;new_vector&#39; and combine it with a new &#39;cbindexample&#39; of 2 columns by using &#39;rbind&#39; where both are concatenated and stored to &#39;rbindexample&#39;.
<pre><code>new_vector&lt;- c(16,15)
rbindexample&lt;- rbind(cbindexample,new_vector)
rbindexample
</code></pre>The above code gives the output below where the new row is added with the values of 16 and 15, respectively, in &#39;newid&#39; and &#39;new_colm2&#39;.
<pre><code>newid new_colm2
1 11
2 5
3 3
4 11
5 9
6 12
7 9
8 9
9 13
10 3
11 8
12 10
13 7
14 10
15 9
16 15
</code></pre><h3 id="melt-function-">Melt Function:</h3>
Usage: Melt function used to convert an object to convert into a molten state, means that it takes multiple columns of data and convert it into a single column of data. 
Parameters: melt(data,…,na.rm=FALSE/TRUE, value.name=”value” ), 
Data: Input which you are going to melt. 
...: Input that is passed to or from. 
Na.rm: It is used to convert explicit missing values into implicit missing. 
Value.name:for storing values into variables 
Let&#39;s look at code that you &#39;molt&#39; the data using the id variable into one column with column name and value:
Let&#39;s import the library named &#39;reshape2&#39; using &#39;library()&#39; and use melt to combine the &#39;dfTemp&#39; columns called colm1,colm2,colm3 in a single place called &#39;variable&#39; according to the &#39;id&#39; variable.
<pre><code>library(reshape2)
molted=melt(df_Temp,id.vars=c(&quot;id&quot;))
molted
</code></pre><pre><code>id variable value
1 colm1 15
2 colm1 15
3 colm1 3
4 colm1 14
5 colm1 3
6 colm1 10
7 colm1 2
8 colm1 6
9 colm1 11
10 colm1 5
11 colm1 4
12 colm1 14
13 colm1 6
14 colm1 9
15 colm1 10
1 colm2 11
2 colm2 5
3 colm2 3
4 colm2 11
5 colm2 9
6 colm2 12
7 colm2 9
8 colm2 9
9 colm2 13
10 colm2 3
11 colm2 8
12 colm2 10
13 colm2 7
14 colm2 10
15 colm2 9
1 colm3 14
2 colm3 3
3 colm3 4
4 colm3 14
5 colm3 1
6 colm3 11
7 colm3 7
8 colm3 5
9 colm3 12
10 colm3 15
11 colm3 10
12 colm3 13
13 colm3 7
14 colm3 9
15 colm3 9
</code></pre>The above output shows that when you molt the data of colm1, colm2, colm3 according to the id variable, it combined into one column named as &#39;variable&#39; and the values of the column are contained in &#39;value&#39;.
<h3 id="dcast-function-">Dcast function:</h3>
Usage: when you have a molten dataset then you can convert the molten dataset into an original format using this function. 
Parameters: dcast(data,id_variable~value), 
data: molten data which needs to convert into original form. 
Id_variable: single or multiple columns that used to molten the data of other columns into one column. 
~: after this sign, we use the values or new molted column of the molten dataset.
You can see below code where the &#39;reshape2&#39; is imported using &#39;library()&#39; where &#39;dcast()&#39; takes the first parameter as the data which was performed &#39;molt()&#39; function and the &#39;~&#39; sign with id where the new molted column gets formed.
<pre><code>library(reshape2)
dcast(molted,id~variable)
</code></pre><pre><code>id colm1 colm2 colm3
1 15 11 14
2 15 5 3
3 3 3 4
4 14 11 14
5 3 9 1
6 10 12 11
7 2 9 7
8 6 9 5
9 11 13 12
10 5 3 15
11 4 8 10
12 14 10 13
13 6 7 7
14 9 10 9
15 10 9 9
</code></pre>You can see that the data changes after &#39;molt()&#39; function gets changed to the original dataset. There are three columns with their respective values in the columns and id in the separate column.
<h3 id="transpose-function-">Transpose function:</h3>
Usage: It is used to change the rows into columns and columns into rows. 
Parameters: t(data), data is the data frame which you need to pass and get transpose.
Let&#39;s change the row to column and vice-versa by using the transpose function. It can be simply done by using &#39;t(df_Temp)&#39; as done below.
<pre><code>trans &lt;- t(df_Temp)
trans
</code></pre>The above code gives following output:
<pre><code>colm1 15 15 3 14 3 10 2 6 11 5 4 14 6 9 10
colm2 11 5 3 11 9 12 9 9 13 3 8 10 7 10 9
colm3 14 3 4 14 1 11 7 5 12 15 10 13 7 9 9
id 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
</code></pre>You can see that the data frame having the shape of 15 rows and four columns is changed into 15 columns and 3 rows by getting transpose of data.
<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 different functions like &#39;rbind(),&#39;cbind()&#39;, along with &#39;Melt()&#39;, &#39;Dcast()&#39;, and finally about the transpose function.
If you would like to learn more about R, take DataCamp&#39;s<a href="https://www.datacamp.com/courses/free-introduction-to-r"> Introduction to R course.</a>
References: 
<a href="https://www.rdocumentation.org/packages/reshape2/versions/1.4.3/topics/melt">Melt functions</a>

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

Learn about data reshaping in R, different functions like rbind(), cbind(), along with Melt(), Dcast(), and finally about the transpose function.

(Tutorial)  Data Reshaping in R

 Data Reshaping in R

The help of its own Interpreter does type checking in Python. Since Python is a dynamic language, it doesn&#39;t force the user to enforce the type of the objects, which can lead to bugs, and errors will be hard to find. To overcome this, Python can be used in conjunction with various other tools and implement features of static type checking along with its own Duck Typing.
There are two different types of type systems followed by different programming languages, which are shown below.
<ol>
 <li>Static Typed Language</li>
 <li>Dynamic Typed Language</li> </ol>

<h2 id="static-typed-language">Static Typed Language</h2>
The type checking of the variable type is done at compile-time. Also, the type system of the language forces to explicitly declare the &#39;data-type&#39; of the variable before its usage. The programming languages which are statically typed are: Scala, Java, C++, etc. 
For example, the declaration of String in Scala is defined below: 
<code>var myCar:String = &quot;Mercedes&quot;;</code> 
The above code shows that the variable name &#39;myCar&#39; is explicitly declared as &#39;String&#39; data-type with the value as &#39;Mercedes&#39;.
<h2 id="dynamic-typed-language">Dynamic Typed Language</h2>
The type checking of the variable type is done at run-time. Also, the type system of the language doesn&#39;t force to explicitly declare the &#39;data-type&#39; of the variable before its usage. The programming languages which are dynamically typed are: Python, Javascript, Ruby, etc. 
For example, the String in Python is defined below: 
<code>myCar = &quot;Mercedes&quot;</code> 
The above code shows that the variable name &#39;myCar&#39; doesn&#39;t need to be explicitly declared.
<h2 id="-type-and-isinstance-in-python">&#39;type()&#39; and &#39;isinstance()&#39; in Python</h2>
The variable types can be known using Python&#39;s own &#39;type()&#39;. The &#39;type()&#39; can be used at runtime for the debugging purpose to identify the exact variable types in the program. Let&#39;s look at the type of some variables in the example below.
<pre><code class="lang-python">my_var = 12
print(type(my_var))
</code></pre>
The above code will give output as &#39;int&#39;. Since the data type of the variable is integer where &#39;type()&#39; plays a role in identifying it.
The &#39;insinstance(&#39;obj&#39;,&#39;class&#39;)&#39; of Python can be used to know whether the &#39;obj&#39;, which is the object is the instance of the class or not. The returned output value is boolean can be one of True or False.
<pre><code class="lang-python">my_var = &quot;Hello&quot;
print(isinstance(my_var,str))
</code></pre>
The above code will give output as True. Since the data type of the variable is a string, where &#39;isinstance()&#39; plays a role in identifying it.
<h2 id="duck-typing-in-python">Duck typing in Python</h2>
There is a popular principle in Python, &quot;If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.&quot; Simply the principle is saying that the types of object or class don&#39;t matter, but object needs to contains similar methods and properties, then the object can be used for a particular purpose. 
Let&#39;s look at an example to clarify the above statement in more detail.
Let&#39;s look at the below example, where there are two classes &#39;Duck&#39; and &#39;Human&#39;. Also, Duck is the class which contains methods as a quack and fly. Similarly, Human is a class with its own set of methods &#39;quack&#39; and &#39;fly&#39;. The Duck and Human are a different class and also a different object or type. However, Human contains similar methods as &#39;fly&#39; and &#39;quack&#39; in Duck.
There is also a method &#39;fly_quack&#39;, which mostly resembles with the &#39;Duck&#39; than &#39;Human&#39; because it can fly and quack.
<pre><code class="lang-python">class Duck:
 def quack(self):
 print(&#39;Quack&#39;)
 def fly(self):
 print(&#39;Flap&#39;)
class Human:
 def quack(self):
 print(&#39;Trying to Quack like a duck&#39;)
 def fly(self):
 print(&#39;Spreading my arm to flap like a duck&#39;) 
def fly_quack(thing):
 thing.quack()
 thing.fly()
</code></pre>
Let&#39;s make an instance of &#39;Duck&#39; as du and pass to function &#39;fly_quack(du)&#39;. Similarly, for Human instance &#39;h&#39; is made and pass to function &#39;fly_quack(h)&#39;.
<pre><code class="lang-python">du = Duck()
fly_quack(du)
h = Human()
fly_quack(h)
</code></pre>
The output of the above code is below:
<pre><code>Trying to Quack like a duck
Spreading my arm to flap like a duck
Quack
Flap
</code></pre>Since the class, &#39;Human&#39; is a different class than &#39;Duck&#39;, but the Python does call the function &#39;fly_quack&#39; for human too. Though object types were different since the &#39;Human&#39; has similar quack and fly methods, it behaves and provides the method required.
<h2 id="type-hint-and-mypy">Type Hint and mypy</h2>
There is a powerful aspect of Dynamic typed Language like Python, which helps the code with accessibility and readable, but there are some downsides too. One of the downsides is to find the run time errors because Python doesn&#39;t enforce the type of the variable, or it is Dynamic typed language. The result of this can produce error and bugs, which will be difficult to find when the code length becomes larger and larger.
Python has implemented Type Hints from version 3.5. The older version might not support the functionality of TypeHints.
You&#39;ll see the simple example of without type hinting and mypy.
The function below is for the subtraction of an integer value, which subtracts two integers and returns the value.
<pre><code class="lang-python">def sub_this(x,y):
 return &#39;Subtraction&#39;
print(sub_this(8,&#39;hello&#39;))
</code></pre>
Here the function above needs to accept two integers &#39;x&#39; and &#39;y&#39;, but since the rules are not imposed, can take any data type. Also, the return value can be anything where the &#39;str&#39; value(&#39;Subtraction&#39;) is returned, but expected was &#39;int&#39;.
Let&#39;s see the similar implementation of the above program, but by using type hints and &#39;mypy&#39;, which can help to implement static type checking and reduce error and bugs in the program quite easily.
&#39;mypy&#39; is a python module which helps in a static type checking, which uses the Python&#39;s own dynamic checking or duck typing with the type-hinting.
You need to install &#39;mypy&#39; packages 
<code>pip install mypy</code>
You can create a file named &#39;mypy_example.py&#39; in your local machine and type the following code. 
The below code is a simple program that accepts two integers as an input in the parameter and after &#39;-&gt;&#39; shows the returned data type, which is also an &#39;int&#39;. However, the function needs to return int, but string &#39;Subtracted two integers&#39; is returned.
<pre><code class="lang-python">def sub_this(x:int,y:int) -&gt; int:
 return &#39;Subtracted two integers&#39;
print(sub_this(8,4))
</code></pre>
Run your above code in the terminal with the following code. 
<code>mypy mypy_example.py</code> 
Then the error will be shown, which indicates that the unexpected return value &quot;str&quot; is found and needs to be resolved with &quot;int&quot;.
<img src="https://i.imgur.com/AK25iIi.png">
Let&#39;s change the return type to be the subtraction of the two integers so that the integer value gets returned.
<pre><code class="lang-python">def sub_this(x:int,y:int) -&gt; int:
 return x - y
print(sub_this(8,4))
</code></pre>
<img src="https://i.imgur.com/tNvmE12.png">
The above results show that the success message gets printed out, and no issues were found.
<h2 id="congratulations">Congratulations</h2>
Congratulations, you have made it to the end of this tutorial!
In this tutorial, you&#39;ve learned about type checking, different types of the type system in various languages with Python method(&#39;type()&#39;, and &#39;isinstance()&#39;) along with duck typing with Python and type hinting combined with &#39;mypy.&#39;
If you would like to learn more about Python, take DataCamp&#39;s <a href = "https://www.datacamp.com/courses/software-engineering-for-data-scientists-in-python/">Software Engineering for Data Scientists in Python</a>.
References:
<ol>
<li><a href="https://www.youtube.com/watch?v=x3v9zMX1s4s&t=85s">Corey&#39;s Youtube video Duck Typing</a></li>
</ol>

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

Learn about type checking, different types of the type system in various languages along with duck typing, and type hinting.

(Tutorial) Type Checking in Python

Type Checking 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.
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588353328/unit9_ys353w.png" style="width:100%">
<figcaption><center><a href="https://coreyms.com/development/python/python-tutorial-unit-testing-code-unittest-module">Source</a </center></figcaption>
</figure>


Unit testing is a software testing method by which individual units of source code are put under various tests to determine whether they are fit for use (<a href="https://medium.com/dsckiit/a-guide-to-using-catch2-for-unit-testing-in-c-f0f5450d05fb">Source</a>). It determines and ascertains the quality of your code.
Generally, when the development process is complete, the developer codes criteria, or the results that are known to be potentially practical and useful, into the test script to verify a particular unit&#39;s correctness. During test case execution, various frameworks log tests that fail any criterion and report them in a summary.
The developers are expected to write automated test scripts, which ensures that each and every section or a unit meets its design and behaves as expected.
Though writing manual tests for your code is definitely a tedious and time-consuming task, Python&#39;s built-in unit testing framework has made life a lot easier.
The unit test framework in Python is called <code>unittest</code>, which comes packaged with Python.
Unit testing makes your code future proof since you anticipate the cases where your code could potentially fail or produce a bug. Though you cannot predict all of the cases, you still address most of them.
A unit could be bucketed into various categories:
<ul>
<li>An entire module,</li>
<li>An individual function,</li>
<li>A complete interface like a class or a method.</li>
</ul>
The best ways to write unit tests for your code is to first start with a smallest testable unit your code could possibly have, then move on to other units and see how that smallest unit interacts with other units, this way you could build up a comprehensive unit test for your applications.
Python&#39;s unit testing framework was inspired by java&#39;s <code>JUnit</code> and has similar features as major unit testing frameworks in other languages. Python&#39;s unit testing framework offers various features like (Source: <a href="https://www.tutorialspoint.com/unittest_framework/unittest_framework_overview.htm">TutorialsPoint</a>)
<ul>
<li>Test automation</li>
<li>Sharing of setup and shutdown code for tests</li>
<li>Aggregating tests into collections</li>
<li>Independence of the tests from the reporting framework</li>
</ul>
Now let&#39;s take an example and understand why there would be a need to have a unit testing of your code.
Let&#39;s write a code to calculate the volume of a cube in Python.
<pre><code class="lang-python">def cuboid_volume(l):
 return (l*l*l)
</code></pre>
<pre><code class="lang-python">length = [2,1.1, -2.5, 2j, &#39;two&#39;]
</code></pre>
<pre><code class="lang-python">for i in range(len(length)):
 print (&quot;The volume of cuboid:&quot;,cuboid_volume(length[i]))
</code></pre>
<pre><code>The volume of cuboid: 8
The volume of cuboid: 1.3310000000000004
The volume of cuboid: -15.625
The volume of cuboid: (-0-8j)



---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

&lt;ipython-input-7-67e1c37a435f&gt; in &lt;module&gt;
 1 for i in range(len(length)):
----&gt; 2 print (&quot;The volume of cuboid:&quot;,cuboid_volume(length[i]))


&lt;ipython-input-2-f50464fd88da&gt; in cuboid_volume(l)
 1 def cuboid_volume(l):
----&gt; 2 return (l*l*l)


TypeError: can&#39;t multiply sequence by non-int of type &#39;str&#39;
</code></pre>The above output should give you some intuition about the importance of having a unit test in place for your code. Now there are three things which are certainly incorrect in the above code:
<ul>
<li>First, the volume of cuboid being negative,</li>
<li>Second, the volume of the cuboid is a complex number,</li>
<li>Finally, the code resulting in a <code>TypeError</code> since you cannot multiply a string, which is a non-int.</li>
</ul>
The third problem thankfully resulted in an error while the first &amp; second still succeeded even though the volume of the cuboid cannot be negative and a complex number.
Unit tests are usually written as a separate code in a different file, and there could be different naming conventions that you could follow. You could either write the name of the unit test file as the <code>name of the code/unit + test</code> separated by an underscore or <code>test + name of the code/unit</code> separated by an underscore.
For example, let&#39;s say the above code file name is <code>cuboid_volume.py</code>, then your unit test code name could be <code>cuboid_volume_test.py</code>
Without any further ado, let&#39;s write the unit test for the above code.
First, let&#39;s create a python file with the name <code>volume_cuboid.py</code>, which will have the code for calculating the volume and second with the name <code>test_volume_cuboid.py</code>, which will have the unit testing code.
<pre><code class="lang-python">import unittest
</code></pre>
The <code>TestCuboid</code> class inherits the <code>unittest</code> module, and in this class, you would define various methods that you would want your unit test should check with your function <code>cuboid_volume</code>.
The first function you will define is <code>test_volume</code>, which will check whether the output your <code>cuboid_volume</code> gives is equal to what you expect. To achieve this, you will make use of the <code>assertAlmostEqual</code> method.
<pre><code class="lang-python">class TestCuboid(unittest.TestCase):
 def test_volume(self):
 self.assertAlmostEqual(cuboid_volume(2),8)
 self.assertAlmostEqual(cuboid_volume(1),1)
 self.assertAlmostEqual(cuboid_volume(0),0)
 self.assertAlmostEqual(cuboid_volume(5.5),166.375)
</code></pre>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588353326/unit1_asqn4b.png" style="width:100%">
</figure>

<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588353326/unit2_bansbt.png" style="width:100%">
</figure>

Let&#39;s run the above script. You would run the <code>unittest</code> module as a script by specifying <code>-m</code> while running it.
<pre><code class="lang-python">!python -m unittest test_volume_cuboid.py
</code></pre>
<pre><code>.
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK
</code></pre>Great! So you got your first unit test code working.
The test ran successfully and returned, <code>OK</code>, which means the cuboid_volume function works as you would expect it too.
Let&#39;s see what happens when one of the <code>assertAlmostEqual</code> methods fails.
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588353326/unit3_kbfbvn.png" style="width:100%">
</figure>

Notice that the last assert statement has been modified.
<pre><code class="lang-python">!python -m unittest test_volume_cuboid.py
</code></pre>
<pre><code>F
======================================================================
FAIL: test_volume (test_volume_cuboid.TestCuboid)
----------------------------------------------------------------------
Traceback (most recent call last):
 File &quot;C:\Users\hda3kor\Documents\Unit_Testing_Python\test_volume_cuboid.py&quot;, line 15, in test_volume
 self.assertAlmostEqual(cuboid_volume(5.5),0)
AssertionError: 166.375 != 0 within 7 places (166.375 difference)

----------------------------------------------------------------------
Ran 1 test in 0.001s

FAILED (failures=1)
</code></pre>Well, from the above output, you can observe that the last assert statement resulted in an <code>AssertionError</code>, hence a unit test failure. Python&#39;s unit test module shows you the reason for the failure, along with the number of failures your code has.
Now let&#39;s explore another assert method, i.e., <code>assertRaises</code>, which will help you in finding out whether your function <code>cuboid_volume</code> handles the input values correctly.
Let&#39;s say you want to test whether you function <code>cuboid_volume</code> handles the class or type of input, for example, if you pass a string as an input will it handle that input either as an exception or with an if condition since the length of the cuboid can never be a string.
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588353326/unit4_bwux5t.png" style="width:100%">
</figure>


<pre><code class="lang-python">!python -m unittest test_volume_cuboid.py
</code></pre>
<pre><code>F.
======================================================================
FAIL: test_input_value (test_volume_cuboid.TestCuboid)
----------------------------------------------------------------------
Traceback (most recent call last):
 File &quot;C:\Users\hda3kor\Documents\Unit_Testing_Python\test_volume_cuboid.py&quot;, line 17, in test_input_value
 self.assertRaises(TypeError, cuboid_volume, True)
AssertionError: TypeError not raised by cuboid_volume

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)
</code></pre>Great! So from the above output, it is evident that your code <code>volume_cuboid.py</code> doesn&#39;t take care of the input being passed to it properly.
Let&#39;s add a condition in the <code>volume_cuboid.py</code> to check whether the input or length of the cuboid is a boolean or a string and raise an error.
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588353326/unit5_nc9lpp.png" style="width:100%">
</figure>


<pre><code class="lang-python">!python -m unittest test_volume_cuboid.py
</code></pre>
<pre><code>..
----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK
</code></pre>There are a lot of <code>assert</code> methods in the unit test module of Python, which could be leveraged for your testing purposes.
Below are some of the assert methods that exist in the unit test module.
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588353327/unit7_kqu7cq.png" style="width:100%">
<figcaption><center><a href="https://docs.python.org/3/library/unittest.html">Source</a </center></figcaption>
</figure>


To know in detail about the <code>assert</code> methods, check out Python&#39;s <a href="https://docs.python.org/3/library/unittest.html">official documentation</a>. 
You could also learn about them with the help of the <code>Pydoc</code> module, which is similar to a <code>help</code> function in Python. A demonstration of how you could use the Pydoc module to read about the <code>assertCountEqual</code> method&#39;s documentation is shown below.
<pre><code class="lang-python">!python -m pydoc unittest.TestCase.assertCountEqual
</code></pre>
<pre><code>Help on function assertCountEqual in unittest.TestCase:

unittest.TestCase.assertCountEqual = assertCountEqual(self, first, second, msg=None)
 An unordered sequence comparison asserting that the same elements,
 regardless of order. If the same element occurs more than once,
 it verifies that the elements occur the same number of times.

 self.assertEqual(Counter(list(first)),
 Counter(list(second)))

 Example:
 - [0, 1, 1] and [1, 0, 1] compare equal.
 - [0, 0, 1] and [0, 1] compare unequal.
</code></pre>It is important to know that your test methods inside the Class <code>TestCuboid</code> should start with a keyword <code>test</code>. Let&#39;s see what happens when you start your test method with some random name without using the <code>test</code> naming convention.
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588353327/unit8_t2cehy.png" style="width:100%">
</figure> 


<pre><code class="lang-python">!python -m unittest test_volume_cuboid.py
</code></pre>
<pre><code>.
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK
</code></pre>As you can see by changing the <code>test_volume</code> method name to <code>volume</code>, only 1 test was run, i.e., <code>test_input_value</code>. Hence, it is important to name your testing methods with a <code>test</code> keyword at the beginning.
Let&#39;s now run the testing script within the jupyter lab. To achieve this, you would first define the testing script in the jupyter lab, as shown below.
<pre><code class="lang-python"># -*- coding: utf-8 -*-
&quot;&quot;&quot;
Created on Sat Apr 25 20:16:58 2020

@author: Aditya
&quot;&quot;&quot;
from volume_cuboid import *
import unittest

class TestCuboid(unittest.TestCase):
 def test_volume(self):
 self.assertAlmostEqual(cuboid_volume(2),8)
 self.assertAlmostEqual(cuboid_volume(1),1)
 self.assertAlmostEqual(cuboid_volume(0),1)

 def test_input_value(self):
 self.assertRaises(TypeError, cuboid_volume, True)
</code></pre>
Then, you will use the <code>unittest.main()</code> method to run the testing script, you can pass several arguments to the below method, out of which one is <code>verbosity level</code>.
Let&#39;s experiment with different verbosity levels and see how it changes the output description.
<pre><code class="lang-python">unittest.main(argv=[&#39;&#39;],verbosity=0, exit=False)
</code></pre>
<pre><code>----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK





&lt;unittest.main.TestProgram at 0x1de02774348&gt;
</code></pre><pre><code class="lang-python">unittest.main(argv=[&#39;&#39;],verbosity=1, exit=False)
</code></pre>
<pre><code>..
----------------------------------------------------------------------
Ran 2 tests in 0.002s

OK





&lt;unittest.main.TestProgram at 0x1de027a1cc8&gt;
</code></pre><pre><code class="lang-python">unittest.main(argv=[&#39;&#39;],verbosity=2, exit=False)
</code></pre>
<pre><code>test_input_value (__main__.TestCuboid) ... ok
test_volume (__main__.TestCuboid) ... ok

----------------------------------------------------------------------
Ran 2 tests in 0.002s

OK





&lt;unittest.main.TestProgram at 0x1de027a8308&gt;
</code></pre>Lastly, let&#39;s modify the final <code>assertAlmostEqual</code> in the <code>test_volume</code> method and analyze how the verbosity level 2 will show the method failure.
<pre><code class="lang-python"># -*- coding: utf-8 -*-
&quot;&quot;&quot;
Created on Sat Apr 25 20:16:58 2020

@author: Aditya
&quot;&quot;&quot;
from volume_cuboid import *
import unittest

class TestCuboid(unittest.TestCase):
 def test_volume(self):
 self.assertAlmostEqual(cuboid_volume(2),8)
 self.assertAlmostEqual(cuboid_volume(1),1)
 self.assertAlmostEqual(cuboid_volume(0),1)

 def test_input_value(self):
 self.assertRaises(TypeError, cuboid_volume, True)
</code></pre>
<pre><code class="lang-python">unittest.main(argv=[&#39;&#39;],verbosity=2, exit=False)
</code></pre>
<pre><code>test_input_value (__main__.TestCuboid) ... ok
test_volume (__main__.TestCuboid) ... FAIL

======================================================================
FAIL: test_volume (__main__.TestCuboid)
----------------------------------------------------------------------
Traceback (most recent call last):
 File &quot;&lt;ipython-input-28-46ad33b909ee&gt;&quot;, line 14, in test_volume
 self.assertAlmostEqual(cuboid_volume(0),1)
AssertionError: 0 != 1 within 7 places (1 difference)

----------------------------------------------------------------------
Ran 2 tests in 0.003s

FAILED (failures=1)





&lt;unittest.main.TestProgram at 0x1de027b5448&gt;
</code></pre>From the above outputs, the following conclusions can be made:
<ul>
<li>Verbosity level 0 just shows how many tests were run, i.e., 2 tests along with the time it took to run them,</li>
<li>Verbosity level 1 add two dots <code>..</code> which signifies two tests were executed,</li>
<li>Verbosity level 2 shows the detailed method names which were run along with their state <code>ok</code> or <code>FAIL</code>.</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
Congratulations on finishing the tutorial.
This tutorial was a basic introduction to unit testing in python and its importance as a developer. One good exercise for you would be to write a unit test module for any of your past projects. This will give you a good hands-on experience with writing unit tests. Also, try exploring the remaining Assert methods.
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/unit-testing-python

Learn what unit testing is, why its important, and how you can implement it with the help of Python.

Unit Testing 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 id='t1'></a>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588351436/t1_p0bram.png" style="width:100%">
</figure>


<h2 id="introduction">Introduction</h2>
Threading allows you to have different parts of your process run concurrently (Source: <a href="https://realpython.com/courses/threading-python/">RealPython</a>). These different parts are usually individual and have a separate unit of execution belonging to the same process. The process is nothing but a running program that has individual units that can be run concurrently. For example, A web-browser could be a process, an application running multiple cameras simultaneously could be a process; a video game is another example of a process.
Inside a process comes the concept of multiple threading or commonly known as multi-threading, where multiple threads work together to achieve a common goal. The most crucial benefit of using threads is that it allows you to run the program in parallel.
Let&#39;s understand the concept of threading with the help of an example. Imagine you have an application which counts the number of cars entering and exiting the mall&#39;s parking. Your apparatus has various cameras that monitor the entry and exit connecting to a central device. Each camera will have an algorithm to monitor the flow of cars, which will belong to the same process or program. However, each camera, along with the algorithm it is being run on, could be part of a separate thread. Not only that, but even the frames being read from the camera and the algorithm predicting on the frames could also be two separate threads.
Another example could be a video game in which the process has to run the tasks in parallel like the graphics, user interaction, and networking (while playing multiplayer games) because it has to be responsive at all times. And to accomplish this, it has to make use of the concept of multi-threading, where each thread would be responsible for running each independent and individual task.
A thread has its flow of execution, which means that the process will have multiple things happening at one time.
It is important to note that each process has at least one thread, and that is called the <code>main thread</code>. If your program doesn&#39;t have any defined thread, then it will at least have the main thread, i.e., the process itself.
If you look at the <a href="#t1">above</a> diagram, there is a process that consists of the main thread consisting of global variables and three different threads t1, t2, and t3. Each thread has its local variables and flow of execution of code. The threads generally share the resources of the process, like the resources available to the main thread will also be shared among the three threads t1, t2, and t3. All the threads will have access to the global variables while having their own local variables.
There are different types of threads:
<ul>
<li>Kernel thread</li>
<li>User thread</li>
<li>Combination of kernel and user thread</li>
</ul>
<h4 id="now-let-s-look-at-some-of-the-advantages-of-having-threading-in-your-program-">Now let&#39;s look at some of the advantages of having threading in your program:</h4>
<ul>
<li>Multi-threading allows the program to speed up the execution provided that it has multiple CPUs.
</li>
<li>It also lets you perform other tasks while the I/O operations are being performed with the help of multiple threads or even main thread along with a single thread. For example, the speed at which the frames from the camera are read and inferred by the algorithm will be handled by different threads. Hence, the algorithm will not have to wait for the frame to be inputted, and the frame reading part will not have to wait for the algorithm execution to complete to be able to read the next frame.
</li>
</ul>
<ul>
<li>Threads within the same process can share the memory and resources of the main thread.</li>
</ul>
<h4 id="challenges-of-threading-">Challenges of Threading:</h4>
<ul>
<li>Remember that Python works based on the CPython implementation, which limits only one thread to be run at a time, hence; threading may not speed up all tasks. And the essential reason behind this is Global Interpreter Lock (GIL).
 If you would like to learn about GIL, then feel free to check out <a href="https://www.datacamp.com/community/tutorials/python-global-interpreter-lock">this</a> tutorial.
</li>
<li>If you are looking for speeding up the CPU intensive task, then threading may not be the best solution for you. In such cases, multi-processing is considered to be useful.
</li>
<li>To execute a program comprising of various threads, it needs to switch quickly across threads; hence, scheduling needs to be taken care of in programs where you have a lot of threads.
</li>
<li>Resource sharing can also be a problem since all the threads share the same resources and memory of the global variables. Hence, operations performed in one thread could cause a memory error for another thread, or the other thread might not get the memory to perform its task.
</li>
</ul>
<h4 id="threading-in-python">Threading in Python</h4>
<ul>
<li>In Python, the threading module is a built-in module which is known as <code>threading</code> and can be directly imported.
</li>
<li>Since almost everything in Python is represented as an object, threading also is an object in Python. A thread is capable of
<ul>
<li>Holding data,</li>
<li>Stored in data structures like dictionaries, lists, sets, etc.</li>
<li>Can be passed as a parameter to a function. 
 </li>
</ul>
</li>
<li>A thread can also be executed as a process.
</li>
<li>A thread in Python can have various states like:
<ul>
<li>Wait,</li>
<li>Locked.</li>
</ul>
</li>
</ul>
Let&#39;s now learn how you can implement threading in Python.
<h4 id="thread-module-in-python3">Thread module in Python3</h4>
Note that Python3 is backward compatible with the <code>thread</code> module, which exists in Python2.7. In Python3, it can be imported as <code>_thread</code> module. So, let&#39;s take an example and understand the <code>_thread</code> module.
<pre><code class="lang-python">import _thread #thread module imported
import time #time module
</code></pre>
Let&#39;s define a function called <code>thread_delay</code>, which will take two parameters as an input, i.e., name of the thread and the delay. Inside this function, you will:
<ul>
<li>Define a counter with zero,</li>
<li>Then you will loop around with a while loop which will run for three times,</li>
<li>Inside the while loop, you will put <code>time.sleep()</code> to add delay, this delay will be useful to understand the execution of the thread. This delay will be in seconds,</li>
<li>Then you will increment your counter by 1,</li>
<li>To see whether your thread execution is going smoothly, you will print the name of the thread and the time at which the thread is executed.</li>
</ul>
<pre><code class="lang-python">def thread_delay(thread_name, delay):
 count = 0
 while count &lt; 3:
 time.sleep(delay)
 count += 1
 print(thread_name, &#39;--------&gt;&#39;, time.time())
</code></pre>
Now to add the thread functionality on the above function or to run the above function in the thread, you would use the <code>start_new_thread</code> method, which is inside the <code>_thread module</code>.
Let&#39;s see the docstring of the <code>start_new_thread</code> method.
<pre><code class="lang-python">?_thread.start_new_thread
</code></pre>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588360477/thread_start_new_thread_bti5wa.png" style="width:100%">
</figure>



Let&#39;s pass in the function <code>thread_delay</code> without parenthesis and the two arguments, i.e., thread name and the delay (to visualize the thread execution since it is very fast).
<pre><code class="lang-python">_thread.start_new_thread(thread_delay, (&#39;t1&#39;, 1))
_thread.start_new_thread(thread_delay, (&#39;t2&#39;, 3))
</code></pre>
<pre><code>10916



t1 --------&gt; 1588077856.4221454
t1 --------&gt; 1588077857.4418247
t2 --------&gt; 1588077858.422453
t1 --------&gt; 1588077858.4431
t2 --------&gt; 1588077861.4371448
t2 --------&gt; 1588077864.438915
</code></pre>From the above output, you can see that the thread <code>t1</code> starts executing first. Meanwhile, thread <code>t2</code> waits since there is a 3-second delay, and as soon as that delay is finished, thread <code>t2</code> is executed, and also, the delay for thread <code>t1</code> is just 1 second.
Let&#39;s now change the delay of <code>t2</code> to 5 seconds, which would start <code>t2</code> after <code>t1</code> would have finished executing since <code>t1</code> will take only 3 seconds to complete its execution.
<pre><code class="lang-python">_thread.start_new_thread(thread_delay, (&#39;t1&#39;, 1))
_thread.start_new_thread(thread_delay, (&#39;t2&#39;, 5))
</code></pre>
<pre><code>14632



t1 --------&gt; 1588078001.4087512
t1 --------&gt; 1588078002.4272866
t1 --------&gt; 1588078003.432218
t2 --------&gt; 1588078005.4082909
t2 --------&gt; 1588078010.4268317
t2 --------&gt; 1588078015.4283602
</code></pre><h4 id="implementing-threading-using-the-threading-module">Implementing threading using the Threading module</h4>
Let&#39;s use the same example as you used above, but this time you will use the <code>threading</code> module instead of the <code>_thread</code> module.
<pre><code class="lang-python">import threading
import time
</code></pre>
<pre><code class="lang-python">def thread_delay(thread_name, delay):
 count = 0
 while count &lt; 3:
 time.sleep(delay)
 count += 1
 print(thread_name, &#39;--------&gt;&#39;, time.time())
</code></pre>
Inside the <code>threading</code> module is a <code>Thread</code> class, which is a similar spirit to the <code>start_new_thread</code> function of the <code>_thread</code> module.
Let&#39;s look at the docstring of <code>Thread</code> class, which takes in several parameters like group, target (like a function), args, etc.
<pre><code class="lang-python">?threading.Thread
</code></pre>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588356967/thread1_mcab3p.png" style="width:100%">
</figure>



In the Thread class constructor, you will pass in the target function <code>thread_delay</code> and the arguments of that function.
<pre><code class="lang-python">t1 = threading.Thread(target=thread_delay, args=(&#39;t1&#39;, 1))
t2 = threading.Thread(target=thread_delay, args=(&#39;t2&#39;, 3))
</code></pre>
<a id='t2'></a>
In the threading module, in order to run or execute the thread, you make use of the <code>start()</code> method, which simply responsible for running the thread.
<pre><code class="lang-python">?t1.start
</code></pre>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588356967/thread2_dq8pej.png" style="width:100%">
</figure>




<pre><code class="lang-python">t1.start()
t2.start()
</code></pre>
<pre><code>t1 --------&gt; 1588081121.7790291
t1 --------&gt; 1588081122.7962046
t2 --------&gt; 1588081123.7789369
t1 --------&gt; 1588081123.7980876
t2 --------&gt; 1588081126.7961557
t2 --------&gt; 1588081129.7995002
</code></pre>You will also use the <code>join</code> method, which means that wait until all the thread execution is complete. So whatever code you have written after the <code>join</code> method will only be executed once these threads have terminated.
<pre><code class="lang-python">?t1.join
</code></pre>
<figure>
 <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588356967/thread3_mgzjuo.png" style="width:100%">
</figure>




<pre><code class="lang-python">t1.start()
t2.start()

t1.join()
t2.join()

print(&quot;Thread execution is complete!&quot;)
</code></pre>
<pre><code>t1 --------&gt; 1588081798.7118263
t1 --------&gt; 1588081799.7231226
t2 --------&gt; 1588081800.7129223
t1 --------&gt; 1588081800.730732
t2 --------&gt; 1588081803.7298765
t2 --------&gt; 1588081806.7309563
Thread execution is complete!
</code></pre>Now let&#39;s calculate the volume of cube and square using the threading concept, which is pretty straight forward.
<pre><code class="lang-python">def volume_cube(a):
 print (&quot;Volume of Cube:&quot;, a*a*a)
</code></pre>
<pre><code class="lang-python">def volume_square(a):
 print (&quot;Volume of Square:&quot;, a*a)
</code></pre>
<pre><code class="lang-python">t1 = threading.Thread(target=volume_cube, args=(2))
t2 = threading.Thread(target=volume_square, args=(3))
</code></pre>
<pre><code class="lang-python">t1.start()
t2.start()

t1.join()
t2.join()

print(&quot;Thread execution is complete!&quot;)
</code></pre>
<pre><code>Thread execution is complete!


Exception in thread Thread-9:
Traceback (most recent call last):
 File &quot;C:\Program Files\Anaconda3\lib\threading.py&quot;, line 926, in _bootstrap_inner
 self.run()
 File &quot;C:\Program Files\Anaconda3\lib\threading.py&quot;, line 870, in run
 self._target(*self._args, **self._kwargs)
TypeError: volume_square() argument after * must be an iterable, not int
Exception in thread Thread-8:
Traceback (most recent call last):
 File &quot;C:\Program Files\Anaconda3\lib\threading.py&quot;, line 926, in _bootstrap_inner
 self.run()
 File &quot;C:\Program Files\Anaconda3\lib\threading.py&quot;, line 870, in run
 self._target(*self._args, **self._kwargs)
TypeError: volume_cube() argument after * must be an iterable, not int
</code></pre>Wait; what? As soon as you executed the start method, it resulted in an error. That is because the <code>args</code> parameter expects a tuple, and since the <code>volume_cube</code> and <code>volume_square</code> expects only one parameter, hence, you need to put a comma in the <code>args</code> parameter after specifying the first argument of the functions.
<pre><code class="lang-python">t1 = threading.Thread(target=volume_cube, args=(2,))
t2 = threading.Thread(target=volume_square, args=(3,))
</code></pre>
<pre><code class="lang-python">t1.start()
t2.start()

t1.join()
t2.join()

print(&quot;Thread execution is complete!&quot;)
</code></pre>
<pre><code>Volume of Cube: 8
Volume of Square: 9
Thread execution is complete!
</code></pre>Let&#39;s now learn to use threading as a subclass.
<h4 id="threading-as-a-sub-class">Threading as a sub-class</h4>
In this section, you would learn how to create sub-class from the thread class, which is available inside the threading module, and then create thread instances <code>t1</code> and <code>t2</code> out of that class.
You would use the same <code>thread_delay</code> function here as well.
<pre><code class="lang-python">class DataCampThread(threading.Thread):
 def __init__(self, name, delay):
 threading.Thread.__init__(self)
 self.name = name
 self.delay = delay


 def run(self):
 print(&#39;Starting Thread:&#39;, self.name)
 thread_delay(self.name,self.delay)
 print(&#39;Execution of Thread:&#39;, self.name, &#39;is complete!&#39;)


t1 = DataCampThread(&#39;t1&#39;, 1)
t2 = DataCampThread(&#39;t2&#39;, 3) 

t1.start()
t2.start()

t1.join()
t2.join()

print(&quot;Thread execution is complete!&quot;)
</code></pre>
<pre><code>Starting Thread: t1
Starting Thread: t2
t1 --------&gt; 1588089083.4879806
t1 --------&gt; 1588089084.489222
t1 --------&gt; 1588089085.4909666
Execution of Thread: t1 is complete!
t2 --------&gt; 1588089085.4979634
t2 --------&gt; 1588089088.499365
t2 --------&gt; 1588089091.5012596
Execution of Thread: t2 is complete!
Thread execution is complete!
</code></pre>Now let&#39;s understand the above code step by step:
<ul>
<li>You defined a class as <code>DataCampThread</code>, and in the class argument, you passed in the <code>threading.Thread</code> class. The reason you do that is that you want to create a sub-class from the threading module. Doing this allows you to use all the methods that are available in the <code>threading.Thread</code> class similar to the concept of inheritance.
</li>
<li>Next, you defined the init method of the DataCampThread class and passed in the function along with the delay. The init is a constructor similar to the parameters you passed to the <code>threading.Thread</code> class, here you would be passing to the <code>DataCampThread</code> class.
</li>
<li>Then you initialize the init method of the main threading.Thread class and then equate name and delay.
</li>
<li>Next, you define the <code>run</code> method, recall <a href="#t2">here</a> you defined the <code>start</code> method, which basically underneath the hood calls the <code>run</code> method. Since you have inherited the main class, you are allowed to make changes to the <code>run</code> method. Hence, when you call the <code>start</code> method, whatever modifications you will make in the <code>run</code> method will be reflected now.
</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
Congratulations on finishing the tutorial.
This tutorial was a basic introduction to threading in python. However, threading is a very vast and vital topic, and some concepts might have been left unexplored. Feel free to look at more threading methods like active count, current thread, etc. 
If you would like to learn more, then also check out Python&#39;s <a href="https://docs.python.org/3/library/threading.html">Thread-based Parallelism</a>.
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/threading-in-python

Learn the basic concepts of threading and how you can use it with the help of Python.

Learn the basic concepts of threading and how you can use it with the help of Python

(Tutorial) Definitive Guide: Threading in Python

Definitive Guide: Threading in Python

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

Learn how to create data visualizations in Python using Altair and a Movies Dataset.

(Tutorial) Altair in Python: Data Visualizations

Altair in Python: Data Visualizations

https://www.datacamp.com/community/tutorials/amazon-web-scraping-using-beautifulsoup

Learn what web scraping is and how it can be achieved with the help of Python's beautiful soup library. Learn by using Amazon website data.

Learn what web scraping is and how it can be achieved with the help of PYTHON's beautiful soup library. Learn by using AMAZON website data.

(Tutorial) Web Scraping With Python: Beautiful Soup

Web Scraping With Python: Beautiful Soup

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

(Tutorial) Estimating COVID-19's 𝑅𝑡 in Real-Time (Replicating in R)

Estimating COVID-19's 𝑅𝑡 in Real-Time (Replicating in R)

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

Learn about the different types of docstrings and various docstring formats like Sphinx, Numpy and Pydoc.

(Tutorial) Docstrings in Python

Docstrings in Python

A string is a character that is made of one character or contains a collection of characters. It is enclosed inside single quotes(&#39;This is a string&#39;) or inside the double quotes(&quot;This is also a string&quot;). But in the internal representation of R strings are represented in double-quotes.
In this tutorial, you will learn about strings in R, and we&#39;ll cover the following topics. 
<ol>
<li>First, you will look into Strings in R and Rule for String in R.</li>
<li>After that, you&#39;ll dive the Concatenation of String in R with other essential properties of String.</li>
<li>Also, Extracting and Replacing a Character String is explained in detail.</li>
<li>Finally, Formatting String, which might be any vector input converted to the well-formatted format.</li>
</ol>
<h2 id="rule-for-string-in-r">Rule for String in R</h2>
<ol>
<li>The string that starts with a single quote needs to end with a single quote. However, you can put double quotes, and through the Escape Sequence(&#39;\&#39;) single quote can also become a part of the string.</li>
 For example: &#39;cars&#39;, &#39;merry&quot;s&#39; , &#39;merry\&#39;s&#39; are valid string in R. 
<li>The string that starts with double-quote needs to end with a double quote. However, you can put single quotes, and through the Escape Sequence(&#39;\&#39;), double-quote can also become a part of the string.</li>
 For example: &quot;cars&quot; , &quot;merry&#39;s&quot;, &quot;merry\&quot;s&quot; are also valid string in R.

</ol>

<h2 id="concatenation-of-string">Concatenation of String</h2>
Concatenation of String is making the strings to join or merge. 
The syntax for concatenating strings in R is done by: 
<code>paste(..., sep = &quot;&quot;,collapse = NULL)</code> 
<code>paste0(..., collapse = NULL)</code>
The argument above in paste states that: 
<ol>
<li>&#39;...&#39;- Indicates one or more characters or objects which converts into character vectors.</li>
<li>&#39;sep&#39;- Indicates a separation character</li>
<li>&#39;collapse&#39;- Indicates an optional separation character.</li>
</ol>
For example, let&#39;s consider the example below where the variables contain the character string:
<code>
my.var1 = &quot;I&quot;
my.var2 = &quot;eat&quot;
my.var3 = &quot;rice&quot;
print(paste(my.var1,my.var2,my.var3))
</code>
The above code gives a single string as below: 
<pre><code>&quot;I eat rice&quot;
</code></pre>For example, let&#39;s consider the example below where the variables contain the vector converted into a single string:
<code>
my.var1 = c(&#39;Book&#39;,&#39;Copy&#39;)
my.var2 = c(&#39;Pen&#39;,&#39;Chair&#39;)
print(paste(my.var1,my.var2,sep=&quot; &quot;,collapse=&quot;-&quot;))
</code>
The above code gives the following output: 
<pre><code>&quot;Book Pen-Copy Chair&quot;
</code></pre>Here, the output contains a &#39;-&#39; between Pen and Copy due to the use of a collapse, which makes the separation between two different vectors. In contrast, the sep includes a space(&#39; &#39;), where individual items are separated by it.
Let&#39;s consider the example containing paste0() 
paste0() takes an argument as sep =,&#39;&#39; i.e. without space and use for its efficiency.
<pre><code>state.name &lt;- paste0(&#39;Mary&#39;,&#39;l&#39;,&#39;and&#39;)
print(state.name)
</code></pre>The output of the above code is below where all characters are merged to be one, and there is no separate space through sep. 
<pre><code>&quot;Maryland&quot;
</code></pre><h2 id="finding-length">Finding Length</h2>
nchar(char,type, allowNA,keepNA) - Finding the total number of characters in a given vector. 
nzchar(char)- Returns TRUE if the x is non-empty and FALSE if it contains any string. 
The argument above in paste states that: 
<ol>
<li>char- Indicates a character vector.</li>
<li>type- Indicates a one of the three types, i.e, &quot;width&quot;,&quot;chars&quot;,&quot;bytes&quot;.</li>
<li>allowNA- Indicates a Logical default value as FALSE and incase the result cannot be calculated will not be an error but returns NA.</li>
<li>keepNA- Indicates a Logical default value as FALSE where it will map the missing value to 2 and nzchar() will give TRUE, but both will map to TRUE as well in the case of the missing values.
 </li>
</ol>
In the example below to determine the length of a character vector.
<code>
my.char = nchar(&quot;hello&quot;)
print(my.char) </code>
The above example returns &#39;5&#39;, as the output because there are five characters present in the vector.
For the example of using nzchar() let&#39;s look at the code below:
<code>
new.char = nzchar(&quot;monkey&quot;)
print(new.char)
</code>
The above code gives the logical value &#39;TRUE&#39; because the &#39;new.char&#39; is not a empty string.
<code>
my.char = nzchar(&quot;&quot;)
print(my.char)
</code>
The above code gives the logical value &#39;FALSE&#39; because the &#39;my.char&#39; is a empty string.
<h2 id="changing-to-upper-case-and-lower-case">Changing to Upper Case and Lower Case</h2>
toupper(char) - Changes all the characters present to uppercase. 
tolower(char) - Changes all the characters present to lowercase.
Let&#39;s look at the example for changing into uppercase.
<code>
 my.var = toupper(&quot;I&#39;m changed to upper case&quot;)
 print(my.var)
</code>
The above code gives the output as below where each character present in the variable &#39;my.var&#39; changed into uppercase. 
<pre><code>&quot;I&#39;M CHANGED TO UPPER CASE&quot;
</code></pre>Let&#39;s look at the example for changing into lowercase.
<code>
 my.var = tolower(&quot;I&#39;m changed to lower case&quot;)
 print(my.var)
</code>
The above code gives the output as below where each character present in the variable &#39;my.var&#39; changed into lowercase. 
<pre><code>&quot;&quot;i&#39;m changed to lower case&quot;&quot;
</code></pre><h2 id="extracting-and-replacing-a-character-string">Extracting and Replacing a Character String</h2>
substr(char, start, stop): Extracting and Replacing of a character string. 
The argument above states that:
<ol>
<li>char- Indicates a character string.</li>
<li>start - Indicates an integer that specifies the corresponding starting value to be returned.</li>
<li>stop - Indicates an integer that specifies the corresponding stopping value to be returned.</li>
</ol>
Let&#39;s see another example where the characters get extracted.
<pre><code>final.value &lt;- substring(&#39;Remaining&#39;, 3, 9)
print(final.value)
</code></pre>In the above code,&#39;Remaining&#39; is a string where the first index is &#39;R&#39;, which is indexed as integer 1. The last character is g with its index as integer 9.
The above code shows the output below where starting value as integer 3, which has the corresponding character as &#39; m &#39; in &#39;Remaining&#39;.Similarly, other characters &#39;ainin&#39; up to integer 9, which is inclusive with the corresponding character as &#39;g&#39;, gets printed out. 
<pre><code>&quot;maining&quot;
</code></pre>Let&#39;s see another example where the characters get replaced.
<pre><code>y = &quot;Remaining&quot;
substring(y, 3, 5) &lt;- &quot;der&quot;
print(y)
</code></pre>The above code shows the output where the starting integer value from 3 to 5 with corresponding character value in y gets replaced by &#39;der&#39;. 
<pre><code>&quot;Rederning&quot;
</code></pre>substring(char, first, last = 1000000L): Extracting or Replacing of a character string. 
The argument above states that:
<ol>
<li>char- Indicates a character string.</li>
<li>first - Indicates an integer which specifies the corresponding first value to be returned.</li>
<li>last - Indicates an integer which specifies the corresponding last value to be returned and default value to 1000000L.</li>
</ol>
<pre><code>my.value &lt;- substring(&#39;Remaining&#39;, 3, 8)
print(my.value)
</code></pre>The above code shows the output below where starting value as integer 3, which has the corresponding character as &#39; m &#39; in &#39;Remaining&#39;.Similarly, other characters up to integer 8, which is inclusive with the corresponding character as &#39;n&#39; get printed out. 
<pre><code>&quot;mainin&quot;
</code></pre>Let&#39;s see another example where the characters get replaced.
<pre><code>y = &quot;newcharacter&quot;
substring(y, 6,9) &lt;- &quot;???&quot;
print(y)
</code></pre>The above code shows the output where the starting integer value from 6 to 9 with corresponding character value in y gets replaced by &#39;???&#39;. 
<pre><code>&quot;newch???cter&quot;
</code></pre><h2 id="formatting-string">Formatting String</h2>
format(char,width,scientific,justify,nsmall,digits): It converts a vector of integer and character to a commonly used format. 
The argument above states that:
<ol>
<li>char - can be a vector of integers or characters.</li>
<li>width - indicates a minimum width of string produced.</li>
<li>scientific - default as FALSE but use TRUE for scientific notation.</li>
<li>justify - default to none but can display strings to &quot;right&quot;, &quot;left&quot;, and &quot;center&quot;.</li>
<li>nsmall - indicates the total number after the decimal place</li>
<li>digits - indicates the total number before and after decimal place.</li>
</ol>
Let&#39;s take an example for formatting string for scientific notation. 
<pre><code>my.var &lt;- format(c(2, 19.267), scientific = TRUE)
print(my.var)
</code></pre>The above code shows the output, which is expressed in scientific or exponential notation
<pre><code>&quot;2.0000e+00&quot; &quot;1.9267e+01&quot;
</code></pre>The output &quot;1.9267e+01&quot; = 1.9267 x 10(to the 1 power) = 1.9267x10 = 19.267.
Let&#39;s take an example of formatting using the nsmall.
<pre><code>my.var &lt;- format(92.56656577, nsmall = 6)
print(my.var)
</code></pre>The above code gives the output as below where the 6 numbers after decimal place are included. 
<pre><code>&quot;92.566565&quot;
</code></pre>Let&#39;s take an example of formatting using the digits.
<pre><code>my.var &lt;- format(102.848793834, digits = 7)
print(my.var)
</code></pre>The above code gives the output as below where the number before starting decimal place are included up to the number after the decimal place. 
<pre><code>&quot;102.8488&quot;
</code></pre>Seven numbers are included as the output where the last digit needs to be 7, but due to the preceding number, i.e., 9 is greater than 7, it gets increased to 8. In simple words, round-off takes place.
Let&#39;s take an example for formatting using the right justify.
<pre><code>my.var &lt;- format(&#39;Running&#39;, justify = &#39;r&#39;,width = 9)
print(my.var)
</code></pre>The above code gives the output as below where the character &#39;Running&#39; is justified to the right with some space of width. 
<pre><code>&quot; Running&quot;
</code></pre>Let&#39;s take an example of formatting using the justify character in the center.
<pre><code>my.var &lt;- format(&#39;Running&#39;, justify = &#39;c&#39;,width = 12)
print(my.var)
</code></pre>The above code gives the output as below where the character &#39;Running&#39; is justified to center with some space of width between right and left. 
<pre><code>&quot; Running &quot;
</code></pre><h2 id="congratulations">Congratulations</h2>
Congratulations, you have made it to the end of this tutorial!
You&#39;ve learned about R&#39;s Strings: its rules, concatenation, along with essential properties of the string, Extracting and Replacing a Character String, and formatting a string.
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/strings-in-r

Learn about R's Strings: its rules, concatenation, along with essential properties of the string, extracting and replacing a character string, and formatting a string.

(Tutorial) Strings in R

Strings in R

An array is a data structure that can hold multi-dimensional data. In R, the array is objects that can hold two or more than two-dimensional data. For example, in square matrices can contain two rows and two columns and dimension can take five.
Arrays can store the values having only a similar kind of data types. The data can be more than one dimensional, where there are rows and columns and dimensions of some length.
<h2 id="creation-of-an-array-">Creation of an Array:</h2>
The array() function will create an array which takes a vector, which is the numbers and dimension(&#39;dim&#39;) in the argument.
Let&#39;s see an example below where two vectors named &#39;array1&#39; and array2&#39; are created.
<pre><code class="lang-python">vector1 = c (5, 10, 15,20)
vector2 = c (25, 30, 35, 40, 45, 50,55,60)
</code></pre>
You can take two vectors above as an input to an array where the dimension is considered as 4 * 4, and two matrices or dimensional data is created.
<pre><code class="lang-python">final = array (c (array1, array2),dim =c(4,4,3))
print (final)
</code></pre>
The output of the above code is below :
<pre><code>, , 1

 [,1] [,2] [,3] [,4]
[1,] 5 25 45 5
[2,] 10 30 50 10
[3,] 15 35 55 15
[4,] 20 40 60 20

, , 2

 [,1] [,2] [,3] [,4]
[1,] 25 45 5 25
[2,] 30 50 10 30
[3,] 35 55 15 35
[4,] 40 60 20 40

, , 3

 [,1] [,2] [,3] [,4]
[1,] 45 5 25 45
[2,] 50 10 30 50
[3,] 55 15 35 55
[4,] 60 20 40 60
</code></pre>Let&#39;s rename our array to &quot;Arr1&quot; and &quot;Arr2&quot; by using &quot;matrix.names&quot;.Also,the rows name changed to (&quot;row1&quot;,&quot;row2&quot;) and column names will be changed to (&quot;column1&quot;,&quot;column2&quot;,&quot;column3&quot;) respectively.The dimension of the matrix is 2 rows and 3 columns.
<pre><code class="lang-python">array1 = c (9 , 18 )
array2 = c (27,36)
r.names = c (&quot;column1&quot;,&quot;column2&quot;,&quot;column3&quot;)
c.names = c (&quot;row1&quot;,&quot;row2&quot;)
m.names = c (&quot;Arr1&quot;, &quot;Arr2&quot;)

final = array (c (array1,array2), dim=c (2,3,2), dimnames=list (c.names, r.names, m.names))
print(final)
</code></pre>
The output of the above code is below, where there are two rows and three columns. Also, the value in the column gets repeated when once it is finished:
<pre><code>, , Arr1

 column1 column2 column3
row1 9 27 9
row2 18 36 18

, , Arr2

 column1 column2 column3
row1 27 9 27
row2 36 18 36
</code></pre><h2 id="indexing-in-an-array">Indexing in an array</h2>
An array consists of elements in a multi-dimensional manner where each element can be accessed for the operation. The elements can be indexed by using &#39;[]&#39; wherein the array-like matrices consists of rows and columns which can be indexed by:
<code>mat[row, column]</code>
Let&#39;s take an example below where the array contains vector input from 1 to 9.There are only three rows and columns where the value is from 1 to 9 is included.The &#39;c.names)&#39; is the new column name which have vectors (&#39;c1&#39;, &#39;c2&#39;, &#39;c3&#39;) and &#39;r.names&#39; is the new row names (&#39;r1&#39;, &#39;r2&#39;, &#39;r3&#39;) which is also the vector.
<pre><code class="lang-python">a1= c (1,2,3,4)
a2= c (5,6,7,8,9)
r.names = c (&quot;c1&quot;,&quot;c2&quot;,&quot;c3&quot;)
c.names = c (&quot;r1&quot;,&quot;r2&quot;,&quot;r3&quot;)
m.names = c (&quot;first&quot;)

arr = array (c (a1,a2), dim=c (3,3,1), dimnames=list (c.names, r.names, m.names))
print(arr)
</code></pre>
<pre><code>, , first

 c1 c2 c3
r1 1 4 7
r2 2 5 8
r3 3 6 9
</code></pre>The output of the above code is below:
<pre><code> , , first

 c1 c2 c3
r1 1 4 7
r2 2 5 8
r3 3 6 9
</code></pre>You can see the matrices from 1 to 9 are generated with 3 3 dimension(row column) form, and the names of rows and columns are changed.
Let&#39;s see how the elements in the array can be extracted with the following examples.
<ol>
<li>Let&#39;s extract number &#39;7&#39; from the above array &#39;arr&#39;.</li>
</ol>
<pre><code class="lang-python">arr[1,3,1]
</code></pre>
7
The output to the above code is 7.Inside of &#39;arr[1,3,1]&#39; row 1 with column 3 and 1 is the first array &#39;arr&#39;is extracted. 
<ol>
<li>To access 1, &#39;arr[1,1,1]&#39; row 1 with column 1 and 1 is the first array &#39;arr&#39;is extracted.</li>
</ol>
<pre><code class="lang-python">arr[1,1,1]
</code></pre>
1
The output to the above code is 1. 
<ol>
<li>To access multiple values at once, you need to specify the range you want.</li>
</ol>
<pre><code class="lang-python">arr[1:2,1:2,1]
</code></pre>
<div class="output_wrapper"><table>
<thead><tr><th></th><th scope=col>c1</th><th scope=col>c2</th></tr></thead>
<tbody>
 <tr><th scope=row>r1</th><td>1</td><td>4</td></tr>
 <tr><th scope=row>r2</th><td>2</td><td>5</td></tr>
</tbody>
</table></div>



The above code gives the output as below where the value containing 2 rows, 2 columns and 1 is the first array &#39;arr&#39; is extracted:
<pre><code> c1 c2
r1 1 4
r2 2 5
</code></pre><ol>
<li>You can access the entire array &#39;arr&#39; with the following syntax where &#39;arr[ , ,1]&#39; specifies to include all rows and columns each separated by commas, which are indicated by space. The 1 specifies the array &#39;arr&#39; to be extracted.</li>
</ol>
<pre><code class="lang-python">arr[ , ,1]
</code></pre>
<div class="output_wrapper"><table>
<thead><tr><th></th><th scope=col>c1</th><th scope=col>c2</th><th scope=col>c3</th></tr></thead>
<tbody>
 <tr><th scope=row>r1</th><td>1</td><td>4</td><td>7</td></tr>
 <tr><th scope=row>r2</th><td>2</td><td>5</td><td>8</td></tr>
 <tr><th scope=row>r3</th><td>3</td><td>6</td><td>9</td></tr>
</tbody>
</table></div>



The above code gives the output as below where all the elements are present:
<pre><code> c1 c2 c3
r1 1 4 7
r2 2 5 8
r3 3 6 9
</code></pre><ol>
<li>You can get the entire second row by following code where arr[2, ,1] gets the second row with space, and 1 is the &#39;arr&#39; to be extracted.</li>
</ol>
<pre><code class="lang-python">arr[2,,1]
</code></pre>
<dl class=dl-horizontal>
 <dt>c1</dt>
 <dd>2</dd>
 <dt>c2</dt>
 <dd>5</dd>
 <dt>c3</dt>
 <dd>8</dd>
</dl>



The above code gives the output as below and also prints c1,c2,c3.
<pre><code>c1 2
c2 5
c3 8
</code></pre><ol>
<li>You can get the entire second column by following code where arr[,2,1] space with 2 is the second column, and 1 is the &#39;arr&#39; to be extracted.</li>
</ol>
<pre><code class="lang-python">mat[ ,2,1]
</code></pre>
<dl class=dl-horizontal>
 <dt>r1</dt>
 <dd>4</dd>
 <dt>r2</dt>
 <dd>5</dd>
 <dt>r3</dt>
 <dd>6</dd>
</dl>



The above code gives the output as below and also prints r1,r2,r3.
<pre><code>r1 4
r2 5
r3 6
</code></pre><h2 id="matrix-creation-and-addition">Matrix Creation and Addition</h2>
Let&#39;s create a matrix named mat1 and mat2 from &#39;arr[ , ,1]&#39; where the entire rows and columns from &#39;arr&#39; get copied.
<pre><code class="lang-python">mat1 = arr[,,1]
mat2 = arr[,,1]
</code></pre>
<pre><code> c1 c2 c3
r1 2 8 14
r2 4 10 16
r3 6 12 18
</code></pre>Add two matrices &#39;mat1&#39; and &#39;mat2&#39; and store the result in final. The output is also printed.
<pre><code class="lang-python">final &lt;- mat1+mat2
print(final)
</code></pre>
The output below shows that each row and columns of mat1 and mat2 are added to one another.
<pre><code> c1 c2 c3
r1 2 8 14
r2 4 10 16
r3 6 12 18
</code></pre><h2 id="apply-">apply()</h2>
&#39;apply()&#39; is one of the R packages which have several functions that helps to write code in an easier and efficient way. You&#39;ll see the example below where it can be used to calculate the sum of two different arrays.
The syntax for apply() is : 
<code>apply(x, margin, function)</code>
The argument above indicates that: 
x: An array or two-dimensional data as matrices. 
margin: Indicates a function to be applied as margin value to be c(1) for rows, c(2) for columns, and c(1,2) for both rows and columns. 
function: Indicates the R- built-in or user-defined function to be applied over the given data.
Let&#39;s create a vector named &#39;array1&#39; of length three and &#39;array2&#39; of length six with the following code.
<pre><code class="lang-python">array1 = c(5,10,15)
array2 = c(15,20,25,30,35,40)
</code></pre>
You can see below where &#39;array()&#39; accepts two vectors named &#39;array1&#39; and &#39;array2&#39; with a dimension of 3 rows, 3 columns, and 2 matrices are created and stored to &#39;my. Array&#39;.
<pre><code class="lang-python">my.Array &lt;- array(c(array1,array2),dim = c(3,3,2))
print(my.Array)
</code></pre>
<pre><code>, , 1

 [,1] [,2] [,3]
[1,] 5 15 30
[2,] 10 20 35
[3,] 15 25 40

, , 2

 [,1] [,2] [,3]
[1,] 5 15 30
[2,] 10 20 35
[3,] 15 25 40
</code></pre>The above code gives the following output, where two matrices are created with the 3 3 (rows columns).
<pre><code>, , 1

 [,1] [,2] [,3]
[1,] 5 15 30
[2,] 10 20 35
[3,] 15 25 40

, , 2

 [,1] [,2] [,3]
[1,] 5 15 30
[2,] 10 20 35
[3,] 15 25 40
</code></pre>&#39;apply()&#39; is used below to calculate the sum of the two matrices by column-wise.
<pre><code class="lang-python">final &lt;- apply(my.Array, c(2), sum)
print(final)
</code></pre>
<pre><code>[1] 60 120 210
</code></pre>You can see above where c(2) for margin is used where the elements of the matrix in &#39;my. Array&#39; is summed by column-wise to get the following output.
<pre><code>60 120 210
</code></pre>Finally, &#39;apply()&#39; is used below to calculate the sum of the two matrices by row-wise.
<pre><code class="lang-python">final &lt;- apply(my.Array, c(1), sum)
print(final)
</code></pre>
<pre><code>[1] 100 130 160
</code></pre>You can see above where c(1) for margin is used where the elements of the matrix in &#39;my. Array&#39; is summed by row-wise to get the following output.
<pre><code>100 130 160
</code></pre><h2 id="congratulations">Congratulations</h2>
Congratulations, you have made it to the end of this tutorial!
You&#39;ve learned about R&#39;s Array along with its creation, indexing in an array with examples, also with creation and addition of matrices along with the apply() function.
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>
References: 
<a href="https://www.tutorialspoint.com/r/r_arrays.htm">R-Arrays</a> 
<a href="https://data-flair.training/blogs/r-array/">R Array Function and Create Array in R</a>

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

Learn about Arrays in R, including indexing with examples, along with the creation and addition of matrices and the apply() function.

(Tutorial) Arrays in R

Arrays in R

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.