https://www.datacamp.com/community/tutorials/recommender-systems-python

Build your recommendation engine with the help of Python, from basic models to content-based and collaborative filtering recommender systems.

Follow our tutorial & Sklearn to build Python recommender systems using content based and collaborative filtering models. Build your very own recommendation engine today!

Python Recommender Systems: Content Based & Collaborative Filtering Recommendation Engines

Beginner Tutorial: Recommender Systems in Python

https://www.datacamp.com/community/tutorials/reading-writing-files-python

Learn how to use Python to read and write data into files such as CSV, JSON, text, and binary files. Follow this tutorial to leverage Python IO and OS modules to open, read, write, and save your data today.

Use Python to read and write data to your files. Learn how to open, load, & save data to and from binary files with Python. Follow our step-by-step guide today!

Python Read & Write to Files: Learn How to Open, Load, Read & Save Data & Binary Files in Python

Reading and Writing Files in Python

https://www.datacamp.com/community/tutorials/python-excel-tutorial

Learn how to read and import Excel files in Python, write data to these spreadsheets, and find the best packages to do this.

Learn how to use excel with Python. Follow our step-by-step tutorial to read and import Excel files with Pandas and openpyxl. Find your ultimate guide to Excel with Python today!

Python Excel Tutorial: Your Definitive Guide with Pandas & openpyxl

Python Excel Tutorial: The Definitive Guide

<p>If you&#39;re familiar with Python or any other programming language, you&#39;ll undoubtedly know that variables need to be defined before they can be used in your program. In this tutorial, you will start with <a href="#initialization">variable initialization</a>. Next, you will get familiar with the boundary of variables within a program - its &quot;scope&quot;. You will learn about the four different scopes with the help of examples: <a href="#local">local</a>, <a href="#enclosing">enclosing</a>, <a href="#global">global</a>, and <a href="#builtin">built-in</a>. These scopes together form the basis for the LEGB rule used by the Python interpreter when working with variables. Then after, you will revisit some examples with additional complexity to open the way for the <a href="#globalkeyword">global keyword</a> followed by the <a href="#nonlocal">nonlocal keyword</a>.</p>
<p><a id='initialization'></a></p>
<h2 id="variable">Variable</h2>
<p>A variable is a label or a name given to a certain location in memory. This location holds the value you want your program to remember, for use later on. What&#39;s great in Python is that you do not have to explicitly state what the type of variable you want to define is - it can be of any type (string, integer, float, etc.). To create a new variable in Python, you simply use the <strong>assignment operator</strong> (<code>=</code>, a single equals sign) and assign the desired value to it.</p>
<pre><code class="lang-python">first_string_var = &quot;First String&quot;  
first_int_var = 1
total = 1 + 2 * 3
</code></pre>
<p>Assigning an initial value to a variable is called <strong>initializing</strong> the variable. You just initialized the variable: <code>first_string_var</code> with a string value of <em>First String</em> and variable <code>first_int_var</code> with an integer or numeric value of <em>1</em>.<br>
The part to the left of the assignment operator is the variable name, and the right side is its value. The right-hand side can also be an arithmetic operation - in which case, it will be evaluated before the assignment occurs.</p>
<p>Python has some rules that you must follow when creating a variable...</p>
<ul>
<li>It may only contain letters (uppercase or lowercase), numbers or the underscore character <code>_</code>.</li>
<li>It may not start with a number.</li>
<li>It may not be a keyword (you will learn about them later on).</li>
</ul>
<p>If you do not follow these rules, you will get an error. Try it for yourself:</p>
<pre><code class="lang-python"># No spaces are allowed in the variable
first string value = &quot;First string&quot;
</code></pre>
<pre><code>  File &quot;&lt;ipython-input-1-2a2f77c0b400&gt;&quot;, line 2
    first string value = &quot;First string&quot;
               ^
SyntaxError: invalid syntax
</code></pre><pre><code class="lang-python"># Cannot start with a number
1st_string_value = &quot;First String&quot;
</code></pre>
<pre><code>  File &quot;&lt;ipython-input-2-79b210888e10&gt;&quot;, line 2
    1st_string_value = &quot;First String&quot;
                   ^
SyntaxError: invalid syntax
</code></pre><pre><code class="lang-python"># Cannot be a keyword

True = &quot;True&quot;
</code></pre>
<pre><code>  File &quot;&lt;ipython-input-3-5d4d2170e79c&gt;&quot;, line 3
    True = &quot;True&quot;
                 ^
SyntaxError: can&#39;t assign to keyword
</code></pre><h2 id="variable-scope">Variable Scope</h2>
<p>Now that you know how to initialize a variable. Let&#39;s talk about the scope of these variables. Not all variables can be accessed from anywhere in a program. The part of a program where a variable is accessible is called its scope. There are four major types of variable scope and is the basis for the <strong>LEGB rule</strong>. LEGB stands for <strong>Local -&gt; Enclosing -&gt; Global -&gt; Built-in</strong>.</p>
<p>Let&#39;s learn more about scopes...</p>
<p><a id='local'></a></p>
<h2 id="local-scope">Local Scope</h2>
<p>Whenever you define a variable within a function, its scope lies ONLY within the function. It is accessible from the point at which it is defined until the end of the function and exists for as long as the function is executing (<a href="https://python-textbok.readthedocs.io/en/1.0/Variables_and_Scope.html">Source</a>). Which means its value cannot be changed or even accessed from outside the function. Let&#39;s take a simple example:</p>
<pre><code class="lang-python">def print_number():
    first_num = 1
    # Print statement 1
    print(&quot;The first number defined is: &quot;, first_num)

print_number()
# Print statement 2
print(&quot;The first number defined is: &quot;, first_num)
</code></pre>
<pre><code>The first number defined is:  1



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

NameError                                 Traceback (most recent call last)

&lt;ipython-input-10-17d580e01222&gt; in &lt;module&gt;
      6 print_number()
      7 # Print statement 2
----&gt; 8 print(&quot;The first number defined is: &quot;, first_num)


NameError: name &#39;first_num&#39; is not defined
</code></pre><p>We were able to print the <code>first_num</code> variable by calling the function <code>print_number()</code> (# Print statement 1). But when trying to access and then print the same variable from outside the function (# Print statement 2), it raised a <code>NameError</code>. This is because <code>first_num</code> is &quot;local&quot; to the function - thus, it cannot be reached from outside the function body.</p>
<p><a id='enclosing'></a></p>
<h2 id="enclosing-scope">Enclosing Scope</h2>
<p>What if we have a nested function (function defined inside another function)? How does the scope change? Let&#39;s see with the help of an example.</p>
<pre><code class="lang-python">def outer():
    first_num = 1
    def inner():
        second_num = 2
        # Print statement 1 - Scope: Inner
        print(&quot;first_num from outer: &quot;, first_num)
        # Print statement 2 - Scope: Inner
        print(&quot;second_num from inner: &quot;, second_num)
    inner()
    # Print statement 3 - Scope: Outer
    print(&quot;second_num from inner: &quot;, second_num)

outer()
</code></pre>
<pre><code>first_num from outer:  1
second_num from inner:  2



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

NameError                                 Traceback (most recent call last)

&lt;ipython-input-4-13943a1eb01e&gt; in &lt;module&gt;
     11     print(&quot;second_num from inner: &quot;, second_num)
     12
---&gt; 13 outer()


&lt;ipython-input-4-13943a1eb01e&gt; in outer()
      9     inner()
     10     # Print statement 3 - Scope: Outer
---&gt; 11     print(&quot;second_num from inner: &quot;, second_num)
     12
     13 outer()


NameError: name &#39;second_num&#39; is not defined
</code></pre><p>Got an error? This is because you cannot access <code>second_num</code> from <code>outer()</code> (# Print statement 3). It is not defined within that function. However, you can access <code>first_num</code> from <code>inner()</code> (# Print statement 1), because the scope of <code>first_num</code> is larger, it is within <code>outer()</code>. <br>
This is an <strong>enclosing scope</strong>. <code>Outer</code>&#39;s variables have a larger scope and can be accessed from the enclosed function <code>inner()</code>.</p>
<p><a id='global'></a></p>
<h2 id="global-scope">Global Scope</h2>
<p>This is perhaps the easiest scope to understand. Whenever a variable is defined outside any function, it becomes a global variable, and its scope is anywhere within the program. Which means it can be used by any function.</p>
<pre><code class="lang-python">greeting = &quot;Hello&quot;

def greeting_world():
    world = &quot;World&quot;
    print(greeting, world)

def greeting_name(name):
    print(greeting, name)

greeting_world()
greeting_name(&quot;Samuel&quot;)
</code></pre>
<pre><code>Hello World
Hello Samuel
</code></pre><p><a id='builtin'></a></p>
<h2 id="built-in-scope">Built-in Scope</h2>
<p>This is the widest scope that exists! All the special reserved keywords fall under this scope.
We can call the keywords anywhere within our program without having to define them before use.</p>
<p><strong>Keywords</strong> are simply special reserved words. They are kept for specific purposes and cannot be used for any other purpose in the program.<br>
These are the keywords in Python:</p>
<p><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588956604/keywords_c8hxf4.png" align="left"/><br><br></p>
<h2 id="legb-rule">LEGB Rule</h2>
<p>LEGB (Local -&gt; Enclosing -&gt; Global -&gt; Built-in) is the logic followed by a Python interpreter when it is executing your program.</p>
<p>Let&#39;s say you&#39;re calling <code>print(x)</code> within <code>inner()</code>, which is a function nested in <code>outer()</code>. Then Python will first look if &quot;x&quot; was defined locally within <code>inner()</code>. If not, the variable defined in <code>outer()</code> will be used. This is the enclosing function. If it also wasn&#39;t defined there, the Python interpreter will go up another level - to the global scope. Above that, you will only find the built-in scope, which contains special variables reserved for Python itself.</p>
<p><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588956604/code_dmeddc.png" align="left"/>  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588956604/Scope_fbrzcw.png" align="center"/></p>
<p>So far, so good!</p>
<p>Next, let&#39;s revisit some examples from before to see if they can create problems when the use-case becomes slightly more complex.</p>
<h3 id="scenario-1-global-scope">Scenario 1: Global Scope</h3>
<p>Remember the <code>greeting_world()</code> function from earlier? Let&#39;s say you wanted to be able to change the global variable <code>greeting</code>(&quot;Hello&quot;) to set a new value (&quot;Hi&quot;) for the greeting, so that <code>greeting_world()</code> prints &quot;Hi World&quot;</p>
<pre><code class="lang-python">greeting = &quot;Hello&quot;

def change_greeting(new_greeting):
    greeting = new_greeting

def greeting_world():
    world = &quot;World&quot;
    print(greeting, world)

change_greeting(&quot;Hi&quot;)
greeting_world()
</code></pre>
<pre><code>Hello World
</code></pre><p>Well...that did not go as wanted! Why?</p>
<p>This is because when we set the value of <code>greeting</code> to &quot;Hi&quot;, it created a new local variable <code>greeting</code> in the scope of <code>change_greeting()</code>. It did not change anything for the global <code>greeting</code>. This is where the <strong>global keyword</strong> comes in handy.</p>
<p><a id='globalkeyword'></a></p>
<h2 id="global-keyword">Global Keyword</h2>
<p>With <strong>global</strong>, you&#39;re telling Python to use the globally defined variable instead of locally creating one. To use the keyword, simply type &#39;global&#39;, followed by the variable name. Let&#39;s see this in action on Scenario 1.</p>
<pre><code class="lang-python">greeting = &quot;Hello&quot;

def change_greeting(new_greeting):
    global greeting
    greeting = new_greeting

def greeting_world():
    world = &quot;World&quot;
    print(greeting, world)

change_greeting(&quot;Hi&quot;)
greeting_world()
</code></pre>
<pre><code>Hi World
</code></pre><p>That worked! Let&#39;s move to the next scenario...</p>
<h3 id="scenario-2-enclosing-scope">Scenario 2: Enclosing Scope</h3>
<p>Here, we have a look at the <code>outer()</code> and <code>inner()</code> nested functions from the Enclosing Scope example. Let&#39;s try to change the value of <code>first_num</code> from 1 to 0 from within <code>inner()</code>.</p>
<pre><code class="lang-python">def outer():
    first_num = 1
    def inner():
        first_num = 0
        second_num = 1
        print(&quot;inner - second_num is: &quot;, second_num)
    inner()
    print(&quot;outer - first_num is: &quot;, first_num)

outer()
</code></pre>
<pre><code>inner - second_num is:  1
outer - first_num is:  1
</code></pre><p>It isn&#39;t always that simple, is it! For such purposes, we make use of <strong>nonlocal keyword</strong> within Python.</p>
<p><a id='nonlocal'></a></p>
<h2 id="nonlocal-keyword">Nonlocal Keyword</h2>
<p>This is another handy keyword that allows us to work more flexibly and tidily with variable scopes. The <strong>nonlocal</strong> keyword is useful in nested functions. It causes the variable to refer to the previously bound variable in the closest enclosing scope. In other words, it will prevent the variable from trying to bind locally first, and force it to go a level &#39;higher up&#39;. The syntax is similar to the global keyword.</p>
<pre><code class="lang-python">def outer():
    first_num = 1
    def inner():
        nonlocal first_num
        first_num = 0
        second_num = 1
        print(&quot;inner - second_num is: &quot;, second_num)
    inner()
    print(&quot;outer - first_num is: &quot;, first_num)

outer()
</code></pre>
<pre><code>inner - second_num is:  1
outer - first_num is:  0
</code></pre><p>And there you have it!</p>
<h2 id="conclusion">Conclusion</h2>
<p>You now know what Python&#39;s scope of variables is, the LEGB rule, and how you should use the global and nonlocal keywords. You&#39;ll be able to easily manipulate variables in nested functions, without any problem. To learn more about programming in Python, you should definitely take a look at DataCamp&#39;s <a href="https://learn.datacamp.com/courses/intro-to-python-for-data-science">Intro to Python for Data Science course</a>. It is an interactive course that covers all the basics: from variables and calculations to lists, functions, and packages.</p>


https://www.datacamp.com/community/tutorials/scope-of-variables-python

Learn what variable scopes are all about and get familiar with the 'LEGB' rule. You will also deal with scenarios where you'll get to see the global and nonlocal keywords in action.

Learn about Python variable scopes and the 'LEGB' rule. Follow our step-by-step tutorial and see how global and nonlocal keywords are used today!

Python Variable Scope with Local & Non-local Examples

Scope of Variables in Python

<p>Matrices are the objects which are elements are represented in a two-dimensional structure where mostly the numeric elements are present for doing various computation.</p>
<p>For example, let&#39;s look at the matrix below.</p>
<pre><code>      [,1] [,2] [,3]
[1,]    5    6    7
[2,]    8    9   10
[3,]   11   12   13
</code></pre><p>The above matrix  shows that there are 3 rows and 3 columns.</p>
<p>In R matrix can be created using &#39;matrix()&#39;.</p>
<p>The following way can define the syntax of a matrix in R:</p>
<pre><code class="lang-r">matrix(value, nrow, ncol, byrow, dimnames)
</code></pre>
<p>The above parameter for the matrix are defined below:</p>
<ol>
<li><b>value</b> - specifies the vector input, which is each entry specifies the elements in a matrix.</li>
<li><b>nrow</b> - specifies the size of the row in the matrix.</li>
<li><b>ncol</b> - specifies the size of the column in the matrix.</li>
<li><b>byrow</b> - The boolean value consists of either TRUE or FALSE. If TRUE, the elements of the matrix are arranged in the row, whereas FALSE will arrange the element by column-wise.</li>
<li><b>dimnames</b> - specifies the name given to each element of rows and columns of a matrix.</li>
</ol>
<p>Let&#39;s see an example below where &#39;mat&#39; is the name of a matrix with vector input inside c consisting of values as 8,4,5,6,7,9. It also contains the number of rows, i.e., &#39;nrow&#39; as two and &#39;ncol&#39; as three, which means the dimension of the matrix is 2 * 3. Also, the elements of the matrix are arranged by row, which means the entry of vector input is filled up row-wise.</p>
<pre><code class="lang-r">mat = matrix(c(8,4,5,6,7,9),nrow = 2, ncol = 3,byrow = TRUE)
print(mat)
</code></pre>
<p>The output of the above code is shown below, where there are three columns and two rows where the elements are filled up with row-wise.</p>
<pre><code>      [,1]  [,2] [,3]
[1,]    8    4    5
[2,]    6    7    9
</code></pre><h3 id="naming-rows-and-columns">Naming Rows and Columns</h3>
<p>Let&#39;s create a matrix where there are elements from 1 to 9, with the number of rows to be 3. Also, the rows and columns are named with the vector input containing a list from r1 to r3 and c1 to c3.</p>
<pre><code class="lang-r">mat &lt;- matrix(1:9,  nrow = 3,dimnames = list(c(&quot;r1&quot;,&quot;r2&quot;,&quot;r3&quot;), c(&quot;c1&quot;,&quot;c2&quot;,&quot;c3&quot;)))
mat
</code></pre>
<pre><code>    c1    c2    c3
r1    1    4    7
r2    2    5    8
r3    3    6    9
</code></pre><p>The above output shows that there are elements from 1 to 9 filled through column-wise. Also, the rows and columns are seen by labeling from r1 to r3 and c1 to c3.</p>
<h2 id="accessing-elements-in-a-matrix">Accessing Elements in a matrix</h2>
<p>The below matrix is named as &#39;mat&#39;, where it consists of 3 rows and 3 columns.</p>
<pre><code>    c1    c2    c3
r1    1    4    7
r2    2    5    8
r3    3    6    9
</code></pre><p>For accessing the above elements of a matrix individually, you need to pass a matrix name with a bracket consisting of rows and columns inside.<br></p>
<ul>
<li>To access element 5 from the above matrix following syntax is used.<br>
<code>mat[2,2]</code></li>
<li>To access element 6 from the above matrix following syntax is used.<br>
<code>mat[3,2]</code></li>
<li>To access all the first column of the matrix, i.e., [1 2 3] following syntax is used.<br>
<code>mat[,1]</code></li>
<li>To access all the second row of the matrix, i.e., [2 5 8] following syntax is used.<br>
<code>mat[2,]</code></li>
</ul>
<h2 id="computation-in-the-matrices">Computation in the matrices</h2>
<h3 id="matrix-addition-and-subtraction">Matrix Addition and Subtraction</h3>
<p><b>Condition:</b> The condition for matrix addition and subtraction is the matrices need to have the same dimension where the number of rows and columns need to be identical.
For example</p>
<p>The below matrices mat1 and mat2 consist of dimension 3 * 3, where there are 3 rows and columns where the row number and column number in both matrices are equal.</p>
<pre><code class="lang-r">mat1 &lt;- matrix(c(5,10,15,20,25,30,35,40,45), nrow = 3)
print(mat1)

mat2 &lt;- matrix(c(50,55,60,65,70,75,80,85,90), nrow = 3)
print(mat2)
</code></pre>
<pre><code>     [,1] [,2] [,3]
[1,]    5   20   35
[2,]   10   25   40
[3,]   15   30   45
     [,1] [,2] [,3]
[1,]   50   65   80
[2,]   55   70   85
[3,]   60   75   90
</code></pre><p>The above matrices are printed out where each entry or elements are printed out where the entries are filled by column-wise.</p>
<pre><code class="lang-r">add_output &lt;- mat1 + mat2
cat(&quot;Addition&quot;,&quot;\n&quot;)
print(add_output)


sub_output &lt;- mat1 - mat2
cat(&quot;Subtraction&quot;,&quot;\n&quot;)
print(sub_output)
</code></pre>
<pre><code>Addition
     [,1] [,2] [,3]
[1,]   55   85  115
[2,]   65   95  125
[3,]   75  105  135
Subtraction
     [,1] [,2] [,3]
[1,]  -45  -45  -45
[2,]  -45  -45  -45
[3,]  -45  -45  -45
</code></pre><p>The above output from matrix addition and subtraction is carried where each element of both matrices get added or subtracted. For example, in matrix addition, above the entries with row 1 and column 1, which is 5 in the mat1, gets added to the entries with row 1 and column 1 in the mat2. As a result of it gets output 55. Similarly, all the entries follow a similar process in addition and subtraction to get the above result.</p>
<h3 id="matrix-multiplication-and-division">Matrix Multiplication and Division</h3>
<p><b>Condition</b>: The condition for matrix multiplication and division is the number of rows and columns need to be similar. In other words, the dimension needs to be equal.</p>
<h4 id="matrix-multiplication">Matrix Multiplication</h4>
<p>Let&#39;s see an example below where two matrices named as mat1 and mat2 are taken where a number of rows as three and columns as two are the same. There are six elements in matrices filled in column-wise, and the dimension of each matrix is 3 * 2.</p>
<pre><code class="lang-r">mat1&lt;- matrix(c(2,4,6,8,10,12), nrow = 3,ncol =2)
print(mat1)

mat2 &lt;- matrix(c(14,16,18,20,22,24), nrow = 3,ncol=2)
print(mat2)

final &lt;- mat1 * mat2
print(&#39;------------------&#39;)
cat(&quot;Multiplication&quot;,&quot;\n&quot;)
print(final)
</code></pre>
<pre><code>     [,1] [,2]
[1,]    2    8
[2,]    4   10
[3,]    6   12
     [,1] [,2]
[1,]   14   20
[2,]   16   22
[3,]   18   24
-----------------
Multiplication
     [,1] [,2]
[1,]   28  160
[2,]   64  220
[3,]  108  288
</code></pre><p>The output from matrix multiplication above shows that each element from mat1 and mat2 are multiplied with each other. For example, &#39;mat1[1][1]&#39;, which is 2 gets multiplied to &#39;mat2[1][1]&#39;, which is 14, to get the result as 28. Similarly, the process is followed for every element in both matrices and finally in &#39;mat1[3][2]&#39;, which is 12  and mat2[3][2]&#39; which is 24 to get the result as 288.</p>
<h4 id="matrix-division">Matrix Division</h4>
<p>Let&#39;s see an example below where two matrices named as mat1 and mat2 are taken where a number of rows as three and columns as two are the same. There are six elements in matrices filled in column-wise, and the dimension of each matrix is 3 * 2.</p>
<pre><code class="lang-r">mat1&lt;- matrix(c(2,4,6,8,10,12), nrow = 3,ncol =2)
print(mat1)

mat2 &lt;- matrix(c(14,16,18,20,22,24), nrow = 3,ncol=2)
print(mat2)
final &lt;- mat1 / mat2
print(&#39;--------------&#39;)
cat(&quot;Division&quot;,&quot;\n&quot;)
print(final)
</code></pre>
<pre><code>   [,1] [,2]
[1,]    2    8
[2,]    4   10
[3,]    6   12
     [,1] [,2]
[1,]   14   20
[2,]   16   22
[3,]   18   24
--------------
Division
          [,1]      [,2]
[1,] 0.1428571 0.4000000
[2,] 0.2500000 0.4545455
[3,] 0.3333333 0.5000000
</code></pre><p>The output from the matrix division above shows that each element from mat1 and mat2 are divided with each other. For example, &#39;mat1[1][1]&#39;, which is two gets divided by &#39;mat2[1][1]&#39;, which is 14 , to get the result as 0.1428571. Similarly, the process is followed for every element in both matrices and finally in &#39;mat1[3][2]&#39;, which is 12  and mat2[3][2]&#39; which is 24 to get the result as 0.5000000.</p>
<h2 id="congratulations">Congratulations</h2>
<p>Congratulations, you have made it to the end of this tutorial!</p>
<p>In this tutorial, you&#39;ll learn all about R&#39;s matrix, naming rows and columns, accessing elements also with computation like addition, subtraction, multiplication, and division.</p>
<p>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></p>


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

Learn all about R's matrix, naming rows and columns, accessing elements also with computation like addition, subtraction, multiplication, and division.

(Tutorial) Matrices in R

Matrices in R

<p><a id='idle1'></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.</p>
<figure>
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948327/idle1_b8dexp.png" style="width:100%">
    <figcaption><center><b>Python IDLE</b></center></figcaption>

</figure>


<h2 id="introduction">Introduction</h2>
<p>IDLE stands for Integrated Development and Learning Environment. The story behind the name IDLE is similar to Python. Guido Van Rossum named Python after the British comedy group Monty Python while the name IDLE was chosen to pay tribute to Eric Idle, who was one of the Monty Python&#39;s founding members. IDLE comes bundled with the default implementation of the Python language since the 01.5.2b1 release. It is packaged as an optional part of the Python packaging with many Linux, Windows, and Mac distributions.</p>
<p>IDLE, as shown <a href="#idle1">above</a>, is a very simple and sophisticated IDE developed primarily for beginners, and because of its simplicity, it is highly considered and recommended for educational purposes. It offers a variety of features that you will look in detail along with examples later in this tutorial.</p>
<p>Some of the key features it offers are:</p>
<ul>
<li><p>Python shell with syntax highlighting,</p>
</li>
<li><p>Multi-window text editor,</p>
</li>
<li><p>Code autocompletion,</p>
</li>
<li><p>Intelligent indenting,</p>
</li>
<li><p>Program animation and stepping which allows one line of code to run at a time helpful for debugging,</p>
</li>
<li><p>Persistent breakpoints,</p>
</li>
<li><p>Finally, Call stack visibility.</p>
</li>
</ul>
<h2 id="how-to-install-idle-">How to Install IDLE?</h2>
<ul>
<li><p>One way to install IDLE is to install Python from the officail Python <a href="https://www.python.org/downloads/"> website</a>, as shown below.</p>
<p>  You can download the latest Python versions from this website for different operating systems like windows, Linux, and mac. It also provides you the docker images for Python, which you can directly use if you have a docker installed on your system.</p>
</li>
</ul>
<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948328/idle2_hzfxpi.png"  width="800" height="200">
</div>

<p>Let&#39;s install Python for the Windows operating system.</p>
<h4 id="installing-python-on-windows-os">Installing Python on Windows OS</h4>
<ul>
<li>Since Python2 development has been stopped, let&#39;s install the latest Python version, i.e., 3.8.2.</li>
</ul>
<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948327/idle3_hnkmvb.png"  width="800" height="200">
</div>

<ul>
<li>Install the <code>Windows x86 executable installer</code> file depending on whether you have a 32-bit or 64-bit OS and run that file. Once you run the file, a window will open, as shown below. Make sure you select the <code>install launcher for all users</code> and <code>add Python3.8 to Path</code> along with the recommended installation.</li>
</ul>
<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948328/idle4_jkrljw.png"  width="800" height="200">
</div>

<ul>
<li>Once the installation is complete, go to the start menu and type <code>idle</code> and click on the same. You should now be seeing the IDLE software on your system.</li>
</ul>
<h4 id="idle-with-anaconda">IDLE with Anaconda</h4>
<p>IDLE can also be used through Anaconda. If you already have Anaconda installed on your system, just open the anaconda prompt from the start menu and type <code>idle</code> in the anaconda terminal, as shown below.</p>
<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948327/idle5_yfuyni.png"  width="800" height="200">
</div>

<p>Since IDLE comes packaged with Anaconda, you will need to download Anaconda from <a href="https://www.anaconda.com/">this website</a>.</p>
<p>To learn how to install Anaconda, check out the <a href="https://docs.anaconda.com/anaconda/install/">documentation</a>.</p>
<p>Well, now that you have the IDLE software installed on your respective systems, let&#39;s understand its features in detail.</p>
<h3 id="exploring-idle-software-features">Exploring IDLE Software Features</h3>
<ul>
<li>Remember that it is not advisable to write multiple lines of code that have functions/classes in the IDLE shell. In such cases, you can go to the <code>File</code> option of IDLE and click on <code>New File</code>.</li>
</ul>
<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948327/idle6_xsxlnl.png"  width="800" height="200">
</div>

<ul>
<li><p>IDLE can be customized using the options present in the <code>Format</code>, <code>Edit</code>, and <code>Options</code> menu.</p>
<ul>
<li><h5 id="modifying-the-font-size-go-to-the-options-menu-and-click-configure-idle-">Modifying the font-size: Go to the Options menu and click <code>configure idle</code>.</h5>
<p>From this, you can choose any font face, font size, make the font bold and even calibrate the indentation width you like working with, as shown below.</p>
<p>IDLE provides you this feature so that each and every person can work with a font size he/she is comfortable working with. A lot of times, your monitor screen size is small, and as a result, you need an IDE that can allow you to increase the font size. That&#39;s where IDLE can come into play and give a sense of relief to your eyes.</p>
<p>Not just the font size and style, you can even adjust the indentation, as mentioned before, which is set to 4 spaces by default as per the PEP-8 coding guidelines.</p>
</li>
</ul>
</li>
</ul>
<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948328/idle7_o0c4aj.png"  width="400" height="100">
</div>

<ul>
<li><h3 id="writing-your-first-code-in-idle">Writing your first code in IDLE</h3>
<p>  You will write a small program in which you will import the NumPy library, define two arrays, and sum them up. Finally, you will run the code and see the output in the IDLE shell.</p>
<p>  To be able to import the NumPy library, make sure it is installed on your system. If not, just go to the command prompt and type <code>pip install NumPy</code>.</p>
</li>
</ul>
<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948328/idle8_nufldw.png"  width="800" height="200">
</div>    

<h4 id="call-stack-visibility">Call Stack Visibility</h4>
<p>While writing the above code, you would notice a dialog box on the screen for both the <code>print</code> function and <code>np.sum</code> function. IDLE will give you the details as to what parameters can be passed to the <code>np.sum</code> function. This is one of the more important and less obvious features of IDLE, which shows the <code>call stack</code> in a verbose manner.</p>
<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948328/idle11_ppzjgs.png"  width="800" height="200">
</div>    


<p>To run the above code, go to the run menu and click on the <code>run module</code> option or directly press <code>F5</code>. It should open the IDLE shell along with the output of your program.</p>
<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948328/idle9_bsin4a.png"  width="800" height="200">
</div>


<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948328/idle10_afqp3u.png" width="800" height="200">
</div>

<h4 id="edit-menu-in-idle">Edit Menu in IDLE</h4>
<p>The edit menu in IDLE has a lot of general features like:</p>
<ul>
<li>undo,</li>
<li>redo,</li>
<li>find,</li>
<li>find in files,</li>
<li>replace,</li>
<li>go to the line,</li>
<li>show surrounding parenthesis</li>
</ul>
<p>But one which makes it special is the <code>show completions</code> feature with which you can autocomplete your code. Imagine you are working on a large and complicated project which involves a lot of coding. You might end up spending a lot of time typing the code.</p>
<p>The <code>show complete</code> feature in IDLE helps you in saving typing time by trying to finish the code for you. The Python IDLE is capable of autocompleting only functions and classes. The autocompletion feature can be used by pressing either the tab key or ctrl+space, as shown below:</p>
<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948328/idle12_nuysok.png" align="center" width="600" height="200">
</div>



<p>You already saw the <code>Fonts/Tabs</code> feature, now let&#39;s look at some more features in <code>configure_idle</code> under the options menu.</p>
<ul>
<li><p>Highlights: Here, you can change the color of the code syntax according to your preference and not just that. You can also configure idle to work in dark mode or theme, which is a great feature to have, especially when you want to code for longer duration and give some relief to your eyes.</p>
<p>  By default, idle works in classic mode and can be tuned to work in a dark mode.</p>
</li>
</ul>
<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948328/idle13_wyps2z.png" align="center" width="400" height="100">
</div>

<h4 id="idle-in-dark-theme-">Idle in Dark Theme!</h4>
<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948328/idle14_ajmtb6.png" align="center" width="800" height="400">
</div>

<ul>
<li><p>Keys: This feature lets you map different key presses to actions, also known as keyboard shortcuts. These are vital components to increase your overall productivity while using an IDE. You can either come up with your own keyboard shortcuts or use the default ones.</p>
<p>  As can be seen from the below figure, the keys are represented in the Action - Key format, which shows you the action that is performed when a specific key or keys are used. Though rarely used by developers, the keys feature in IDLE makes your life easier, especially when you want to write a lot of code in a quick manner.</p>
</li>
</ul>
<div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948328/idle15_fbmh97.png" align="center" width="400" height="100">
</div>

<h4 id="format-menu">Format Menu</h4>
<p>Like other menu&#39;s, Format also has few useful features like indent region, dedent region, comment out a region, etc.</p>
<p>Let&#39;s look at the indent region. The indentation in Python is used to segregate a block of code, let&#39;s say you have written a code but missed giving indentations to it, the indent region feature could come to your rescue.</p>
<p>The ident region tab added 4 spaces to the selected lines of code, as shown below:</p>
<p><div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948328/idle16_cwptij.png" align="center" width="500" height="200">
</div> <br>
<br></p>
<p>Similarly, the <code>dedent region</code> will help you in removing any unnecessary spaces from your code.</p>
<h4 id="writing-a-palindrome-code-in-idle">Writing a Palindrome Code in IDLE</h4>
<p>A palindrome is a word, phrase, or sequence of numbers that read the same backward as forward.</p>
<p>For example, sequence 121, 151, etc.</p>
<p>Let&#39;s quickly write the Palindrome code in IDLE and check the output.</p>
<p><div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948329/idle18_swe9ep.png" align="center" width="1000" height="400">
</div> <br>
<br></p>
<p>Let&#39;s now save the above code and run it.</p>
<p><div align="center">
  <img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588948329/IDLE19_i3k7di.png" align="center" width="1000" height="400">
</div> <br>
<br></p>
<p>From the above output, you can observe that in all four experiments, the program expected input from the user, and based on the input, the if-else conditions were executed.     </p>
<h2 id="conclusion">Conclusion</h2>
<p>Congratulations, you have made it to the end of this tutorial!</p>
<p>In this tutorial, you&#39;ve learned about Python IDLE, how to install it, and various features associated with it. Since now you are familiar with IDLE&#39;s features and capabilities, it would be much easier for you to start using it.</p>
<p>Those of you who have just started to learn Python, IDLE would be the best development environment for you to get your hands dirty by starting to code in it.</p>
<p>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/introduction-to-data-science-in-python">Introduction to Data Science in Python</a> course.</p>


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

Learn what is Python IDLE (Integrated Development and Learning Environment)  is, how you can install it, and leverage its various features for writing your Python programs.

(Tutorial) Introduction to Python IDLE

Introduction to Python IDLE

<p>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.</p>
<p>There are two different types of type systems followed by different programming languages, which are shown below.</p>
<ol>
    <li><b>Static Typed Language</b></li>
    <li><b>Dynamic Typed Language</b></li><br></ol>

<h2 id="static-typed-language">Static Typed Language</h2>
<p>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.<br>
For example, the declaration of String in Scala is defined below:<br>
<code>var myCar:String = &quot;Mercedes&quot;;</code><br>
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;.</p>
<h2 id="dynamic-typed-language">Dynamic Typed Language</h2>
<p>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. <br>
For example, the String in Python is defined below:<br>
<code>myCar = &quot;Mercedes&quot;</code><br>
The above code shows that the variable name &#39;myCar&#39; doesn&#39;t need to be explicitly declared.</p>
<h2 id="-type-and-isinstance-in-python">&#39;type()&#39; and &#39;isinstance()&#39; in Python</h2>
<p>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.</p>
<pre><code class="lang-python">my_var = 12
print(type(my_var))
</code></pre>
<p>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.</p>
<p>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.</p>
<pre><code class="lang-python">my_var = &quot;Hello&quot;
print(isinstance(my_var,str))
</code></pre>
<p>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.</p>
<h2 id="duck-typing-in-python">Duck typing in Python</h2>
<p>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.<br>
Let&#39;s look at an example to clarify the above statement in more detail.</p>
<p>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.</p>
<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>
<p>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;.</p>
<pre><code class="lang-python">du = Duck()
fly_quack(du)
h = Human()
fly_quack(h)
</code></pre>
<p>The output of the above code is below:</p>
<pre><code>Trying to Quack like a duck
Spreading my arm to flap like a duck
Quack
Flap
</code></pre><p>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.</p>
<h2 id="type-hint-and-mypy">Type Hint and mypy</h2>
<p>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.</p>
<p>Python has implemented Type Hints from version 3.5. The older version might not support the functionality of TypeHints.</p>
<p>You&#39;ll see the simple example of without type hinting and mypy.</p>
<p>The function below is for the subtraction of an integer value, which subtracts two integers and returns the value.</p>
<pre><code class="lang-python">def sub_this(x,y):
    return &#39;Subtraction&#39;
print(sub_this(8,&#39;hello&#39;))
</code></pre>
<p>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;.</p>
<p>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.</p>
<p>&#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.</p>
<p>You need to install &#39;mypy&#39; packages <br/>
<code>pip install mypy</code></p>
<p>You can create a file named &#39;mypy_example.py&#39; in your local machine and type the following code.<br/>
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.</p>
<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>
<p>Run your above code in the terminal with the following code.<br>
<code>mypy mypy_example.py</code><br></p>
<p>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"></p>
<p>Let&#39;s change the return type to be the subtraction of the two integers so that the integer value gets returned.</p>
<pre><code class="lang-python">def sub_this(x:int,y:int) -&gt; int:
    return x - y
print(sub_this(8,4))
</code></pre>
<p><img src="https://i.imgur.com/tNvmE12.png"></p>
<p>The above results show that the success message gets printed out, and no issues were found.</p>
<h2 id="congratulations">Congratulations</h2>
<p>Congratulations, you have made it to the end of this tutorial!</p>
<p>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;</p>
<p>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>.</p>
<p><b>References:</b></p>
<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

<p>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.</p>
<p>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.</p>
<h2 id="creating-your-data">Creating your data</h2>
<p>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.</p>
<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><p>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.</p>
<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>
<p><b>Usage</b>: used to combine vectors, matrix, and data frames by columns.<br>
<b>Parameters</b>:cbind(v1,v2): v1,v2 can be vectors, matrix or data frames</p>
<p>Let&#39;s see the example of binding in action.</p>
<p>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;.</p>
<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><p>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;.</p>
<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>
<p><b>usage: </b>rbind used to combines the vectors, matrix, or data frames by columns.<br>
<b>Parameters:</b> rbind(v1,v2):v1,v2 can be vectors, matrix or data frames.</p>
<p>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;.</p>
<pre><code>new_vector&lt;- c(16,15)
rbindexample&lt;- rbind(cbindexample,new_vector)
rbindexample
</code></pre><p>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;.</p>
<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>
<p><b>Usage:</b> 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.<br>
<b>Parameters:</b> melt(data,…,na.rm=FALSE/TRUE, value.name=”value” ),<br>
<b>Data:</b> Input which you are going to melt.<br>
<b>...:</b> Input that is passed to or from.<br>
<b>Na.rm:</b> It is used to convert explicit missing values into implicit missing.<br>
<b>Value.name:</b>for storing values into variables<br>
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:</p>
<p>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.</p>
<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><p>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;.</p>
<h3 id="dcast-function-">Dcast function:</h3>
<p><b>Usage:</b> when you have a molten dataset then you can convert the molten dataset into an original format using this function.<br>
<b>Parameters: </b>dcast(data,id_variable~value), <br>
<b>data:</b> molten data which needs to convert into original form.<br>
<b>Id_variable:</b> single or multiple columns that used to molten the data of other columns into one column.<br>
<b>~: </b>after this sign, we use the values or new molted column of the molten dataset.</p>
<p>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.</p>
<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><p>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.</p>
<h3 id="transpose-function-">Transpose function:</h3>
<p><b>Usage:</b> It is used to change the rows into columns and columns into rows.<br>
<b>Parameters:</b> t(data), data is the data frame which you need to pass and get transpose.</p>
<p>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.</p>
<pre><code>trans &lt;- t(df_Temp)
trans
</code></pre><p>The above code gives following output:</p>
<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><p>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.</p>
<h2 id="congratulations">Congratulations</h2>
<p>Congratulations, you have made it to the end of this tutorial!</p>
<p>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.</p>
<p>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></p>
<p><b>References:</b><br>
<a href="https://www.rdocumentation.org/packages/reshape2/versions/1.4.3/topics/melt">Melt functions</a></p>


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

<p>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.</p>
<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>


<p>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.</p>
<p>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.</p>
<p>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.</p>
<p>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.</p>
<p>The unit test framework in Python is called <code>unittest</code>, which comes packaged with Python.</p>
<p>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.</p>
<p>A unit could be bucketed into various categories:</p>
<ul>
<li>An entire module,</li>
<li>An individual function,</li>
<li>A complete interface like a class or a method.</li>
</ul>
<p>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.</p>
<p>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>)</p>
<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>
<p>Now let&#39;s take an example and understand why there would be a need to have a unit testing of your code.</p>
<p>Let&#39;s write a code to calculate the volume of a cube in Python.</p>
<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><p>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:</p>
<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>
<p>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.</p>
<p>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.</p>
<p>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></p>
<p>Without any further ado, let&#39;s write the unit test for the above code.</p>
<p>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.</p>
<pre><code class="lang-python">import unittest
</code></pre>
<p>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>.</p>
<p>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.</p>
<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>

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

<p>Notice that the last assert statement has been modified.</p>
<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><p>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.</p>
<p>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.</p>
<p>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.</p>
<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><p>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.</p>
<p>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.</p>
<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><p>There are a lot of <code>assert</code> methods in the unit test module of Python, which could be leveraged for your testing purposes.</p>
<p>Below are some of the assert methods that exist in the unit test module.</p>
<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>


<p>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>.  </p>
<p>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.</p>
<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><p>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.</p>
<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><p>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.</p>
<p>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.</p>
<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>
<p>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>.</p>
<p>Let&#39;s experiment with different verbosity levels and see how it changes the output description.</p>
<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><p>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.</p>
<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><p>From the above outputs, the following conclusions can be made:</p>
<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>
<p>Congratulations on finishing the tutorial.</p>
<p>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.</p>
<p>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.</p>


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.

Learn how to test your Python code with unittest. Follow our step-by-step  tutorial and bug proof your code today!

Test Python Code with unittest Examples

Unit Testing in Python

<p>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.</p>
<p><a id='t1'></a></p>
<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>
<p>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.</p>
<p>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.</p>
<p>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.</p>
<p>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.</p>
<p>A thread has its flow of execution, which means that the process will have multiple things happening at one time.</p>
<p>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.</p>
<p>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.</p>
<p>There are different types of threads:</p>
<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><p>Multi-threading allows the program to speed up the execution provided that it has multiple CPUs.</p>
</li>
<li><p>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.</p>
</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><p>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).</p>
<p>  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.</p>
</li>
<li><p>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.</p>
</li>
<li><p>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.</p>
</li>
<li><p>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.</p>
</li>
</ul>
<h4 id="threading-in-python">Threading in Python</h4>
<ul>
<li><p>In Python, the threading module is a built-in module which is known as <code>threading</code> and can be directly imported.</p>
</li>
<li><p>Since almost everything in Python is represented as an object, threading also is an object in Python. A thread is capable of</p>
<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.<br>
<br>    </li>
</ul>
</li>
<li><p>A thread can also be executed as a process.</p>
</li>
<li><p>A thread in Python can have various states like:</p>
<ul>
<li>Wait,</li>
<li>Locked.</li>
</ul>
</li>
</ul>
<p>Let&#39;s now learn how you can implement threading in Python.</p>
<h4 id="thread-module-in-python3">Thread module in Python3</h4>
<p>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.</p>
<pre><code class="lang-python">import _thread #thread module imported
import time #time module
</code></pre>
<p>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:</p>
<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>
<p>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>.</p>
<p>Let&#39;s see the docstring of the <code>start_new_thread</code> method.</p>
<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>



<p>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).</p>
<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><p>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.</p>
<p>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.</p>
<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>
<p>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.</p>
<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>
<p>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.</p>
<p>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.</p>
<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>



<p>In the Thread class constructor, you will pass in the target function <code>thread_delay</code> and the arguments of that function.</p>
<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>
<p><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.</p>
<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><p>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.</p>
<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><p>Now let&#39;s calculate the volume of cube and square using the threading concept, which is pretty straight forward.</p>
<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><p>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.</p>
<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><p>Let&#39;s now learn to use threading as a subclass.</p>
<h4 id="threading-as-a-sub-class">Threading as a sub-class</h4>
<p>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.</p>
<p>You would use the same <code>thread_delay</code> function here as well.</p>
<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><p>Now let&#39;s understand the above code step by step:</p>
<ul>
<li><p>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.</p>
</li>
<li><p>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.</p>
</li>
<li><p>Then you initialize the init method of the main threading.Thread class and then equate name and delay.</p>
</li>
<li><p>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.</p>
</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
<p>Congratulations on finishing the tutorial.</p>
<p>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.   </p>
<p>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>.</p>
<p>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.</p>


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 how to scrape the web using Python Beautiful Soup. Follow this step-by-step tutorial and scrape data from Amazon today!

Web Scraping Using Python Beautiful Soup: How to Scrape Data from Amazon Tutorial

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 Python Docstrings. Find different examples & format types of docstrings for Sphinx, Numpy and Pydoc.

See Python Docstrings. Learn about the different types of docstrings & various docstring formats like Sphinx, Numpy, and Pydoc with examples now.

Python Docstrings: Examples & Format for Pydoc, Numpy, Sphinx Doc Strings

Docstrings in Python

<p>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.</p>
<h2 id="creation-of-an-array-">Creation of an Array:</h2>
<p>The array() function will create an array which takes a vector, which is the numbers and dimension(&#39;dim&#39;) in the argument.</p>
<p>Let&#39;s see an example below where two vectors named &#39;array1&#39; and array2&#39; are created.</p>
<pre><code class="lang-python">vector1 =  c (5, 10, 15,20)
vector2 =  c (25, 30, 35, 40, 45, 50,55,60)
</code></pre>
<p>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.</p>
<pre><code class="lang-python">final = array (c (array1, array2),dim =c(4,4,3))
print (final)
</code></pre>
<p>The output of the above code is below :</p>
<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><p>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.</p>
<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>
<p>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:</p>
<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>
<p>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></p>
<p>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.</p>
<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><p>The output of the above code is below:</p>
<pre><code> , , first

   c1 c2 c3
r1  1  4  7
r2  2  5  8
r3  3  6  9
</code></pre><p>You can see the matrices from 1 to 9 are generated with 3 <em> 3 dimension(row </em> column) form, and the names of rows and columns are changed.</p>
<p>Let&#39;s see how the elements in the array can be extracted with the following examples.</p>
<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>
<p>7</p>
<p>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.<br></p>
<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>
<p>1</p>
<p>The output to the above code is 1.<br></p>
<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>



<p>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:</p>
<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>



<p>The above code gives the output as below where all the elements are present:</p>
<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>



<p>The above code gives the output as below and also prints c1,c2,c3.</p>
<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>



<p>The above code gives the output as below and also prints r1,r2,r3.</p>
<pre><code>r1 4
r2 5
r3 6
</code></pre><h2 id="matrix-creation-and-addition">Matrix Creation and Addition</h2>
<p>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.</p>
<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><p>Add two matrices &#39;mat1&#39; and &#39;mat2&#39; and store the result in final. The output is also printed.</p>
<pre><code class="lang-python">final &lt;- mat1+mat2
print(final)
</code></pre>
<p>The output below shows that each row and columns of mat1 and mat2 are added to one another.</p>
<pre><code>   c1 c2 c3
r1  2  8 14
r2  4 10 16
r3  6 12 18
</code></pre><h2 id="apply-">apply()</h2>
<p>&#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.</p>
<p>The syntax for apply() is :<br>
<code>apply(x, margin, function)</code></p>
<p>The argument above indicates that:<br>
<b>x</b>: An array or two-dimensional data as matrices.<br>
<b>margin</b>: 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.<br>
<b>function: Indicates the R- built-in or user-defined function to be applied over the given data.</p>
<p>Let&#39;s create a vector named &#39;array1&#39; of length three and &#39;array2&#39; of length six with the following code.</p>
<pre><code class="lang-python">array1 = c(5,10,15)
array2 = c(15,20,25,30,35,40)
</code></pre>
<p>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;.</p>
<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><p>The above code gives the following output, where two matrices are created with the 3 <em> 3 (rows </em> columns).</p>
<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><p>&#39;apply()&#39; is used below to calculate the sum of the two matrices by column-wise.</p>
<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><p>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.</p>
<pre><code>60 120 210
</code></pre><p>Finally, &#39;apply()&#39; is used below to calculate the sum of the two matrices by row-wise.</p>
<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><p>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.</p>
<pre><code>100 130 160
</code></pre><h2 id="congratulations">Congratulations</h2>
<p>Congratulations, you have made it to the end of this tutorial!</p>
<p>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.</p>
<p>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></p>
<p><b>References:</b><br>
<a href="https://www.tutorialspoint.com/r/r_arrays.htm">R-Arrays</a><br>
<a href="https://data-flair.training/blogs/r-array/">R Array Function and Create Array in R</a></p>


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.

Discover Arrays in R. Follow our step-by-step tutorial and learn how to create & index arrays. Find code examples using R and get started creating arrays today!

community

datacamp

Data Science Tutorials