<p>Tuples are made of several items, just like a list, but they cannot be modified in any way. They are widely used internally in many of the systems we depend on, like databases. Tuples hold data in the order we supply it, and we can access the elements inside a tuple with an index.</p>
<p>For example, if you have a tuple like <code>(&#39;chocolate chip cookies&#39;, 15)</code> and you want to access each part of the data, you can use an index just like a list. Tuples are easier to process and more memory efficient than lists.</p>
<p>They are immutable, which means we cannot add or remove elements from them. This property of tuple is important because we can use them to ensure that our data is not altered. We can create tuples by pairing up elements.</p>
<h2 id="zipping">Zipping</h2>
<p>Often, we will have lists where we want to match up elements into pairs, and the zip function enables us to do that. Tuples are commonly created by zipping lists together with <code>zip()</code>.</p>
<h3 id="example">Example</h3>
<p>Here we have a list of most popular cookies in the US and India, and we want to build a list of pairs by the popularity rank of the cookie in each country, and we will pass them to the zip function. Then we print the result of the <code>zip</code>, and you get what looks like a list of Tuples.</p>
<p>We have two lists: <code>us_cookies</code>, <code>in_cookies</code>.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1594824817/tuple2_tsbt05.png" /></center>

<p>Notice that the tuples use parenthesis as their object representation.</p>
<h2 id="unpacking">Unpacking</h2>
<p>Tuple unpacking, also sometimes called tuple expansion, allows us to assign the elements of a tuple to named variables for later use. Unpacking tuples is a very expressive way of working with data.</p>
<h3 id="example">Example</h3>
<p>The below syntax allows you to create a more readable and less error-prone code. Here we have a tuple containing top-ranked cookie from two countries, and we want to store them as <code>us_num_1</code> and <code>in_num_1</code> so that we can print them name by name.</p>
<p>We start by putting both variables as the target of the assignment statement separated by a comma. Then assign the first tuple in our <code>top_pairs</code> list to them.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1594824817/tuple3_tytwea.png" /></center>


<h3 id="example">Example</h3>
<p>Here we build a <code>for</code> loop that uses tuple unpacking when iterating over the <code>top_pairs</code> list. It splits each tuple in the list into its Indian and US cookie elements. We then use each of these variables to print the cookies in order.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1594824817/tuple4_hoq643.png" /></center>


<h2 id="enumerating-positions">Enumerating Positions</h2>
<p>Another useful tuple creation method is the <code>enumerate()</code> function. Enumeration is used in loops to return the position and the data in that position while looping.</p>
<h3 id="example">Example</h3>
<p>Here we enumerate our top pairs list and split that resulting tuple into index <code>idx</code> and <code>item</code>.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1594824817/tuple5_spx8qm.png" /></center>


<p>To learn more about tuples in Python, please see this video from our course <a href="https://campus.datacamp.com/courses/data-types-for-data-science-in-python/fundamental-data-types?ex=4">Data Types for Data Science in Python</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/U1cl26tYaFM" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

<p>This content is taken from DataCamp’s <a href="https://learn.datacamp.com/courses/data-types-for-data-science-in-python">Data Types for Data Science in Python</a> course by Jason Myers.</p>


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

Learn to use and unpack Tuples in Python.

(Tutorial) Tuples in Python

Tuples in Python

<p>Sometimes you will want to replace occurrences of a substring with a new string, and Python has a built-in method <code>.replace()</code> to achieve it.</p>
<p>Python provides you with the <code>.replace()</code> string method that returns a copy of the string with all the occurrences of old substring replaced with the new substring given as a parameter.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1594823502/regular_find9_eijuac.png" /></center>

<h2 id="arguments">Arguments</h2>
<p>It takes three arguments: the substring to replace, the new string to replace it, and an optional number that indicates how many occurrences to replace.</p>
<ul>
<li><p>old − This is the old substring to be replaced.</p>
</li>
<li><p>new − This is the new substring, which would replace the old substring.</p>
</li>
<li><p>count − If this optional argument count is given, only the first count occurrences are replaced.</p>
</li>
</ul>
<h3 id="example">Example of String Replace</h3>
<p>In the example code below, you will replace the substring house with car. The method will return a copy with all the house substrings replaced.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1594823503/regular_find11_kbonez.png" /></center>

<h3 id="example">Example of String Replace with the Count Optional Argument</h3>
<p>In this second example, you specify that you only want two of the occurrences to be replaced. In the below output, you can see that the method returns the string&#39;s copy with the first two occurrences of house replaced by car.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1594823502/regular_find12_qkymgr.png" /></center>

<h3 id="example">Example</h3>
<p>Here you will replace the substring <code>isn&#39;t</code> for the word <code>is</code>. Then, replace the substring <code>important</code> for the word <code>insignificant</code>, and finally, print out the result contained in the variable <code>movies_antonym</code>.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1594823502/regular_find13_i2k0j9.png" /></center>

<p>When we run the above code, it produces the following result:</p>
<p><code>the rest of the story is insignificant because all it does is serve as a mere backdrop for the two stars to share the screen .</code></p>
<p><a href="https://campus.datacamp.com/courses/regular-expressions-in-python/basic-concepts-of-string-manipulation?ex=12">Try it for yourself</a>.</p>
<p>To learn more about Python String Replace, please see this video from our course, <a href="https://campus.datacamp.com/courses/regular-expressions-in-python/basic-concepts-of-string-manipulation?ex=9">Regular Expressions in Python</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/bJu-lc5coZw?start=198" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

<p>This content is taken from DataCamp’s <a href="https://learn.datacamp.com/courses/regular-expressions-in-python">Regular Expressions in Python</a> course by Maria Eugenia Inzaugarat.</p>


https://www.datacamp.com/community/tutorials/python-string-replace

Learn to find and replace strings using regular expressions in Python.

(Tutorial) Python String Replace

Python String Replace

<p>You can add elements to a list using the append method. The <code>append()</code> method adds a single element towards the end of a list.</p>
<h3 id="example-of-the-append-method">Example of the append() method</h3>
<p>For example, let’s extend the string by adding “April” to the list with the method <code>append()</code>. Using <code>append()</code> will increase the length of the list by 1.</p>
<p><code>list.append()</code> adds a single element to a list</p>
<pre><code class="lang-python">months = [&#39;January&#39;, &#39;February&#39;, &#39;March&#39;]
months.append(&#39;April&#39;)
print(months)
</code></pre>
<pre><code>[&#39;January&#39;, &#39;February&#39;, &#39;March&#39;, &#39;April&#39;]
</code></pre><h2 id="using-list-methods-to-add-data-append-vs-extend-">Using list methods to add data: <code>append()</code> vs. <code>extend()</code></h2>
<p>The <code>.append()</code> method increases the length of the list by one, so if you want to add only one element to the list, you can use this method.</p>
<pre><code class="lang-python">x = [1, 2, 3]
x.append(4)
x
</code></pre>
<pre><code>[1, 2, 3, 4]
</code></pre><p>The <code>.extend()</code> method increases the length of the list by the number of elements that are provided to the method, so if you want to add multiple elements to the list, you can use this method.</p>
<pre><code class="lang-python">x = [1, 2, 3]
x.extend([4, 5])
x
</code></pre>
<pre><code>[1, 2, 3, 4, 5]
</code></pre><h2 id="interactive-example-of-the-append-and-extend-methods">Interactive example of the <code>append()</code> and <code>extend()</code> methods</h2>
<p>We start with the list <code>names</code>:</p>
<pre><code>names =  [&#39;Apple Inc&#39;, &#39;Coca-Cola&#39;, &#39;Walmart&#39;]
</code></pre><pre><code class="lang-python"># Append a name to the list names
names.append(&#39;Amazon.com&#39;)
print(names)
</code></pre>
<p>When we run the above code, it produces the following result:</p>
<pre><code>names =  [&#39;Apple Inc&#39;, &#39;Coca-Cola&#39;, &#39;Walmart&#39;, &#39;Amazon.com&#39;]
</code></pre><p>We can then add two additional elements to the list <code>names</code> using <code>extend()</code> and the <code>more_elements</code> list.</p>
<pre><code class="lang-python"># Extend list names
more_elements = [&#39;DowDuPont&#39;, &#39;Alphabet Inc&#39;]
names.extend(more_elements)
print(names)
</code></pre>
<p>When we run the above code, it produces the following result:</p>
<pre><code>[&#39;Apple Inc&#39;, &#39;Coca-Cola&#39;, &#39;Walmart&#39;, &#39;Amazon.com&#39;, &#39;DowDuPont&#39;, &#39;Alphabet Inc&#39;]
</code></pre><p><a href="https://campus.datacamp.com/courses/introduction-to-python-for-finance/lists-2?ex=10">Try it for yourself</a>.</p>
<p>To learn more about list methods and functions, please see this video from our course <a href="https://campus.datacamp.com/courses/introduction-to-python-for-finance/lists-2?ex=8">Introduction to Python for Finance</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/lnTq2kjUzhw?start=66" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

<p>This content is taken from DataCamp’s <a href="https://www.datacamp.com/courses/introduction-to-python-for-finance">Introduction to Python for Finance</a> course by Adina Howe.</p>


https://www.datacamp.com/community/tutorials/python-list-methods

 Learn how to use the .append() and .extend() methods to add elements to a list.

(Tutorial) Python .append() and .extend() Methods

Python .append() and .extend() Methods

<p>Object-Oriented Programming(OOP) is a  programming paradigm in where different methods are used to design software around data or objects rather than using functions. A method is just a function, talked about in the OOP context. It is object-oriented because all the processing revolves around the objects and fields. Every object has different attributes and behavior.</p>
<p>In Object-Oriented programming, the whole program can be divided into different classes to quickly understand the program execution. R is a functional programming language, and OOP will help manage large system problems. OOP used to manage GUI applications, most likely web-applications. Object-Oriented Programming is good for building tools for data analysis but bad for data analysis itself.</p>
<h3 id="systems-of-oop">Systems of OOP</h3>
<p>There are mainly two major systems of OOP, which are described below:</p>
<ul>
<li><strong>S3 Classes:</strong> These let you overload the functions.</li>
<li><strong>S4 Classes:</strong> These let you limit the data as it is quite difficult to debug the program</li>
</ul>
<p><strong>Note:</strong> These classes will be discussed in detail in the later section.</p>
<h2 id="objects-in-r">Objects in R</h2>
<p>Objects are the instance of the class. Also, everything in R is an object
and to know more look at <a href="https://www.datacamp.com/community/tutorials/data-types-in-r">Data types in R.</a>
They also can have their attributes like class, attributes,dimnnames, names, etc.</p>
<p>For example, objects are assigned a value using <code>&lt;-,</code> consider the following piece of code where &#39;a1&#39; and &#39;a2&#39; are the variables where the numeric value is assigned to it.</p>
<pre><code class="lang-python">a1 &lt;- 10
a2 &lt;- 20
</code></pre>
<p>An object can be assigned a set of numbers where &#39;a3&#39; is the object containing a vector of different numbers.</p>
<pre><code class="lang-python">a3 &lt;- c(10,20,30)
</code></pre>
<p>Here <strong>c</strong> contains the numbers,10, 20, 30 into a vector.</p>
<p>Let&#39;s take a real-life example like a student, which has attributes of name, age, class, and gender, the teacher, has a name, age, and gender.</p>
<pre><code class="lang-python">st_name &lt;- &quot;andrew&quot;
st_age &lt;- 16
st_class &lt;- 10
st_gender &lt;- &quot;male&quot;

t_name &lt;- &quot;angelina&quot;
t_age &lt;- 26
t_gender &lt;- &quot;female&quot;

student &lt;- c(st_name, st_age, st_class, st_gender)
teacher &lt;- c(t_name, t_age, t_gender)


print(student)
print(teacher)
</code></pre>
<pre><code>[1] &quot;andrew&quot; &quot;16&quot;     &quot;10&quot;     &quot;male&quot;  
[1] &quot;angelina&quot; &quot;26&quot;       &quot;female&quot;  
</code></pre><p>The above code gives the following output:</p>
<pre><code>&quot;andrew&quot; &quot;16&quot; &quot;10&quot; &quot;male&quot;  
&quot;angelina&quot; &quot;26&quot;  &quot;female&quot;
</code></pre><p>In the above code, you can see the example where there are different types of objects. The &#39;student&#39; and &#39;teacher&#39; object, also called a variable, hold type &#39;character&#39; and &#39;double.&#39;</p>
<h2 id="class-in-r">Class in R</h2>
<p>Class is the blueprint that helps to create an object and contains its member variable along with the attributes.</p>
<p>As discussed earlier in the previous section, there are two classes of R, S3, and S4.</p>
<h3 id="s3-class">S3 Class</h3>
<p>These classes help in overloading functions by splitting them into generic and methods.</p>
<p>  <strong>functions = generic + methods</strong></p>
<p>S3 is very different from other programming languages like C#, Java, etc. Because it&#39;s straightforward to implement, it uses only the first argument to dispatch. That&#39;s why it doesn&#39;t require too much knowledge as a programmer&#39;s perspective.</p>
<p>S3 works by defining a strict naming convention of generic dot class.</p>
<pre><code>                             generic.class
</code></pre><p>The arguments of methods should contain arguments of generic, and method should include a <strong>...arg</strong>.</p>
<h3 id="constructing-along-with-example-of-s3-class">Constructing along with Example of S3 Class</h3>
<p>You will be demonstrated to construct an S3 class in the following example, which shows the creation of the list where components are being passed along with proper class name followed by the result to be printed.</p>
<p>The following example shows &#39;studentBio&#39; contains a list where components are passed as a list where &#39;student_name,&#39; &#39;student_age,&#39; and &#39;student_contact&#39; are being given. The class is named &#39;Student Info,&#39; and &#39;studentBio&#39; is the newly created class whose values are displayed below.</p>
<pre><code class="lang-python">studentBio &lt;- list(studentName = &quot;Harry Potter&quot;, studentAge = 19, studentContact=&quot;London&quot;)
class(studentBio) &lt;- &quot;StudentInfo&quot;
studentBio
</code></pre>
<pre><code>$studentName
[1] &quot;Harry Potter&quot;

$studentAge
[1] 19

$studentContact
[1] &quot;London&quot;

attr(,&quot;class&quot;)
[1] &quot;StudentInfo&quot;
</code></pre><p>The above code gives the output as below:</p>
<pre><code>$studentName
 &quot;Harry Potter&quot;

$studentAge
19

$studentContact
&quot;London&quot;

attr(,&quot;class&quot;)
&quot;StudentInfo&quot;
</code></pre><p>If you are not comfortable about writing function in R, then read a <a href="https://www.datacamp.com/community/tutorials/functions-in-r-a-tutorial">A Tutorial on Using Functions in R!</a></p>
<h3 id="creating-your-own-generic-method-in-s3">Creating Your Own Generic Method in S3</h3>
<p>You will be implementing your generic function below by using the following code.</p>
<p>The code below shows the generic function called &#39;contact&#39; where the function passing with the object is assigned to it. Also, &#39;UseMethod&#39; is used with the generic function called &#39;contact&#39; is passed where &#39;dispatching&#39; of method occurs, which is the process where the result varies based on the arguments passed.</p>
<pre><code class="lang-python">contact &lt;- function(object) {
UseMethod(&quot;contact&quot;)
}
</code></pre>
<p>Let&#39;s make a method for the particular class that you&#39;ve created earlier named &#39;StudentInfo.&#39;
The method &#39;contact&#39; followed by dot notation along with the class &#39;StudentInfo&#39; is used where the function body contains the access of the attribute  &#39;studentContact&#39; is done by using &#39;$.&#39;</p>
<pre><code class="lang-python">contact.StudentInfo &lt;- function(object) {
cat(&quot;Your contact is&quot;, object$studentContact, &quot;\n&quot;)
}
contact(studentBio)
</code></pre>
<pre><code>Your contact is London
</code></pre><p>The above code uses <code>object$studentContact</code>, where the object passed as an argument to function along with &#39;$&#39; to access attribute &#39;studentContact,&#39; which results in output as below.</p>
<pre><code>Your contact is London
</code></pre><h2 id="s4-class">S4 Class</h2>
<p>S4 Class is stricter, conventional, and closely related to Object-Oriented concepts. The classes are represented by the formal class definitions of S4. More specifically, S4 has setter and getter functions for methods and generics. As compared to the S3 class, S4 can be able to facilitate multiple dispatches.</p>
<p>Let us see the above-discussed classes of R by creating them and discuss with an example.</p>
<p>An S4 class is defined using the set class function.</p>
<pre><code> setClass()
</code></pre><h3 id="constructing-along-with-example-of-s4-class">Constructing along with Example of S4 Class</h3>
<p>As discussed earlier, the S4 class is defined by the setClass() method. You will use the setClass() method to create and define the S4 class. We will use a subroutine to verify that the data is consistent (validation) and also set the default values (the paradigm).</p>
<p>Following is the code to define the class and its slots:</p>
<p>The following is used to define a class, also called &#39;prototype&#39;, where the slots are defined where the class name is &#39;employee&#39;, name is a character, id as a numeric, and contact as a character.</p>
<pre><code class="lang-python">setClass(&quot;employee&quot;, slots=list(name=&quot;character&quot;, id=&quot;numeric&quot;, contact=&quot;character&quot;))
</code></pre>
<p>The following code can create the specific instance or objects of S4.</p>
<p>Let&#39;s create an object using &#39;new&#39; with the class name inside as &#39;employee&#39; with the slots like name, id, and contact are filled with a value.</p>
<pre><code class="lang-python">obj &lt;- new(&quot;employee&quot;,name=&quot;Steven&quot;, id=1002, contact=&quot;West Avenue&quot;)
obj
</code></pre>
<pre><code>An object of class &quot;employee&quot;
Slot &quot;name&quot;:
[1] &quot;Steven&quot;

Slot &quot;id&quot;:
[1] 1002

Slot &quot;contact&quot;:
[1] &quot;West Avenue&quot;
</code></pre><pre><code>An object of class &quot;employee&quot;
Slot &quot;name&quot;:
&quot;Steven&quot;

Slot &quot;id&quot;:
1002

Slot &quot;contact&quot;:
&quot;West Avenue&quot;
</code></pre><p>The above output shows that the object created was of class &quot;employee&quot; and the Slot with &quot;name&quot; called &quot;Steven&quot; along with Slot &quot;id&quot; with value 1002 and Slot &quot;contact&quot; with value is &quot;West Avenue&quot;.</p>
<h3 id="function-and-commands">Function and commands</h3>
<p>For checking whether an object is an S4 object or not following two commands can be used:</p>
<p>The command &#39;is.object(obj)&#39;checks whether a variable or instance refers to an object or not.</p>
<pre><code class="lang-python">is.object(obj)
</code></pre>
<p>TRUE</p>
<p>The above code gives the following output as below:</p>
<pre><code>TRUE
</code></pre><p>The command &#39;is.S4(obj)&#39;checks, whether a variable or instance is an S4 object or not.</p>
<pre><code class="lang-python">isS4(obj)
</code></pre>
<p>TRUE</p>
<p>The above code gives the following output as below:</p>
<pre><code>TRUE
</code></pre><h3 id="accessing-and-modifying-the-slot-value">Accessing and Modifying the slot value</h3>
<h4 id="accessing-the-slot">Accessing the slot</h4>
<p>The slot can be accessed using the &quot;@&quot; instead of &quot;$&quot;.</p>
<p>&#39;obj@name&#39; is used where the object name along with the slot name is to access the name &#39;Steven&#39; and is similarly done to &#39;obj@id&#39;.</p>
<pre><code class="lang-python">obj@name
obj@id
</code></pre>
<p>&#39;Steven&#39;</p>
<p>1002</p>
<p>The above code gives the following output:</p>
<pre><code>&#39;Steven&#39;
1002
</code></pre><h4 id="modifying-the-slot">Modifying the slot</h4>
<p>Let&#39;s modify the slot value just by using the assignment operator(&quot;&lt;-&quot;) where the &#39;obj@contact&#39; is assigned with a new value as &quot;North Avenue&quot;.</p>
<pre><code class="lang-python">obj@contact &lt;- &quot;North Avenue&quot;
obj
</code></pre>
<pre><code>An object of class &quot;employee&quot;
Slot &quot;name&quot;:
[1] &quot;Steven&quot;

Slot &quot;id&quot;:
[1] 1002

Slot &quot;contact&quot;:
[1] &quot;North Avenue&quot;
</code></pre><p>The above code gives the following output:</p>
<pre><code>An object of class &quot;employee&quot;
Slot &quot;name&quot;:
&quot;Steven&quot;

Slot &quot;id&quot;:
1002

Slot &quot;contact&quot;:
&quot;North Avenue&quot;
</code></pre><p>The above output shows that the Slot &quot;contact&quot; has changed it&#39;s value previously &quot;West Avenue&quot; to &quot;North Avenue&quot;.</p>
<p>Alternatively, there is an option to use &#39;slot()&#39; to change the value.</p>
<p>&#39;slot(obj, &quot;id&quot;)&#39; indicates the slot &quot;id&quot; value to ve changed with the assignment of 1004, and the result is printed with &#39;obj&#39;.</p>
<pre><code class="lang-python">slot(obj,&quot;id&quot;) &lt;- 1004
obj
</code></pre>
<pre><code>An object of class &quot;employee&quot;
Slot &quot;name&quot;:
[1] &quot;Steven&quot;

Slot &quot;id&quot;:
[1] 1004

Slot &quot;contact&quot;:
[1] &quot;North Avenue&quot;
</code></pre><pre><code>An object of class &quot;employee&quot;
Slot &quot;name&quot;:
&quot;Steven&quot;

Slot &quot;id&quot;:
1004

Slot &quot;contact&quot;:
&quot;North Avenue&quot;
</code></pre><p>The above output shows that the Slot &quot;id&quot; has changed its value previously 1002 to 1004.</p>
<h3 id="creating-your-own-generic-method-in-s4">Creating Your Own Generic Method in S4</h3>
<p>Let&#39;s create a function that helps print the output according to our needs, where the &#39;setMethod()&#39; and the generic function called &#39;show()&#39; is used. Also, all the slots&#39; value is accessed by &#39;@&#39;, and their names are printed out. Finally, the output is obtained with the help of &#39;obj&#39;.</p>
<pre><code class="lang-python">setMethod(&quot;show&quot;,
&quot;employee&quot;,
function(object) {
cat(&quot;Name:&quot;,object@name, &quot;\n&quot;)
cat(&quot;Id:&quot;,object@id, &quot;\n&quot;)
cat(&quot;Contact:&quot;, object@contact, &quot;\n&quot;)
}
)
obj
</code></pre>
<pre><code>Name: Steven
Id: 1004
Contact: North Avenue
</code></pre><pre><code>Name: Steven
Id: 1004
Contact: North Avenue
</code></pre><p>The above output shows that the results are printed as in the form of Slot names along with respective Slot values.</p>
<h3 id="congratulations">Congratulations</h3>
<p>Congratulations, you have made it to the end of this tutorial!</p>
<p>In this tutorial, you&#39;ve learned about Object-Oriented Programming(OOP) along with R&#39;s objects, different classes like S3 and S4, along with its construction, creating its generic function with examples and many more.</p>
<p>If you would like to learn more about R, take DataCamp&#39;s <a href="https://www.datacamp.com/courses/object-oriented-programming-in-r-s3-and-r6">Object-Oriented Programming with S3 and R6 in R</a>.</p>


https://www.datacamp.com/community/tutorials/r-objects-and-classes

Learn about Object-Oriented Programming(OOP) along with R's objects, different classes like S3 and S4, along with its construction, creating its generic function with examples and many more.

Objects and Classes in R

https://www.datacamp.com/community/tutorials/python-list-comprehension

Learn how to effectively use list comprehension in Python to create lists, to replace (nested) for loops and the map(), filter() and reduce() functions, ...!

(Tutorial) Python List Comprehension

Python List Comprehension

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

Discover the power of regular expressions with this tutorial. You will work with the re library, deal with pattern matching, learn about greedy and non-greedy matching, and much more!

(Tutorial) Python Regular Expression

Python Regular Expression Tutorial

<center>
<a target=“_blank” href="https://www.datacamp.com/learn/r/"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583330891/r_3_ijnnwq.png" /></a>
</center>
<p>The factors are the variable in R, which takes the categorical variable and stores data in levels. The primary use of this function can be seen in data analysis and specifically in statistical analysis. Also, it helps to reduce data redundancy and to save a lot of space in the memory.</p>
<p><b>Note: A categorical variable is those variables that take values based on the labels or names. For example, the blood type of a human can be A, B, AB, or O.</b></p>
<h3 id="factor-function">factor function</h3>
<p><b>Usage:</b> Categorize the data which have less number of values.<br>
<b>Parameters:factor(v):</b>v can be vector of values.</p>
<p>Let&#39;s see the example of a factor in action.<br></p>
<p>You can see below code where there are two categorical variables, namely &quot;Male&quot; and &quot;Female&quot;, also called factor values.</p>
<pre><code class="lang-python">gender &lt;- c(&quot;Male&quot;,&quot;Female&quot;,&quot;Female&quot;,&quot;Male&quot;,&quot;Female&quot;)
</code></pre>
<p>Let&#39;s create a factor for the gender where &#39;factor(gender)&#39; is used and saved to a variable called &#39;gender.factor&#39;.</p>
<pre><code class="lang-python">gender.factor &lt;- factor(gender)
gender.factor
</code></pre>
<ol class=list-inline>
    <li>Male</li>
    <li>Female</li>
    <li>Female</li>
    <li>Male</li>
    <li>Female</li>
</ol>

<details>
    <summary style=display:list-item;cursor:pointer>
        <strong>Levels</strong>:
    </summary>
    <ol class=list-inline>
        <li>&#39;Female&#39;</li>
        <li>&#39;Male&#39;</li>
    </ol>
</details>


<p>The above code gives the output as below:</p>
<pre><code>Male Female Female Male Female
Levels:
&#39;Female&#39; &#39;Male&#39;
</code></pre><p>You can see above where values are printed the same as the input vector. Additionally, &#39;Levels&#39;, which are &#39;Female&#39; and &#39;Male&#39; are sorted alphabetically.</p>
<h3 id="structure-of-factor-function">Structure of factor function</h3>
<p>Let&#39;s examine the structure for factor function by using &#39;str(gender.factor)&#39; in the code below.</p>
<pre><code class="lang-python">str(gender.factor)
</code></pre>
<pre><code> Factor w/ 2 levels &quot;Female&quot;,&quot;Male&quot;: 2 1 1 2 1
</code></pre><pre><code>Factor w/ 2 levels &quot;Female&quot;,&quot;Male&quot;: 2 1 1 2 1
</code></pre><p>The above output shows that there is a factor of 2 levels. factor converts the character vector as gender into a vector of integer values. &quot;Female&quot; is the first level encoded as 1 whereas the &quot;Male&quot; is the second level, encoded as 2.</p>
<p>Also, the primary purpose of encoding from character to numeric is that the categories can belong, repeating is redundant, which can take a lot of space in the memory. But, using factor reduces all the burden to save up space in the memory.</p>
<h3 id="changing-order-levels">Changing Order Levels</h3>
<p>Let&#39;s change the order levels, so the levels of &quot;Female&quot; will become 2 and &quot;Male&quot; as 1.</p>
<p>Let&#39;s make a new factor for the gender by changing the levels of &quot;Male&quot; and &quot;Female&#39; by passing it as a vector input to the &quot;levels&quot;. Finally, the resultant output is saved to the variable named &quot;gender.factor2&#39;.</p>
<pre><code class="lang-python">gender.factor2 &lt;- factor(gender,levels=c(&quot;Male&quot;,&quot;Female&quot;))
gender.factor2
str(gender.factor2)
</code></pre>
<ol class=list-inline>
    <li>Male</li>
    <li>Female</li>
    <li>Female</li>
    <li>Male</li>
    <li>Female</li>
</ol>

<details>
    <summary style=display:list-item;cursor:pointer>
        <strong>Levels</strong>:
    </summary>
    <ol class=list-inline>
        <li>&#39;Male&#39;</li>
        <li>&#39;Female&#39;</li>
    </ol>
</details>


<pre><code> Factor w/ 2 levels &quot;Male&quot;,&quot;Female&quot;: 1 2 2 1 2
</code></pre><p>The &#39;gender.factor2&#39; is printed along with it&#39;s structure printed using &#39;str(gender.factor2)&#39; where the following changes can be seen.</p>
<pre><code>Male Female Female Male Female
 Levels:
&#39;Male&#39; &#39;Female&#39;
 Factor w/ 2 levels &quot;Male&quot;,&quot;Female&quot;: 1 2 2 1 2
</code></pre><p>The above code gives the output where the encoding of &quot;Male&quot; is 1, and &quot;Female&quot; is 2. It&#39;s different from &#39;gender.factor&#39;, which was opposite in the above code.</p>
<h3 id="renaming-a-factor-levels">Renaming a Factor levels</h3>
<p>Let&#39;s change the name of the vector values in the input by specifying the regular use of &#39;levels&#39;  as the first argument with values &quot;Male&quot; and &quot;Female&quot; and the expected changed vector values using &#39;labels&#39; as the second argument with &quot;Gen_Male&quot; and &quot;Gen_Female&quot; respectively.</p>
<pre><code class="lang-python">factor(gender,levels = c(&quot;Male&quot;,&quot;Female&quot;),labels = c(&quot;Gen_Male&quot;,&quot;Gen_Female&quot;))
</code></pre>
<ol class=list-inline>
    <li>Gen_Male</li>
    <li>Gen_Female</li>
    <li>Gen_Female</li>
    <li>Gen_Male</li>
    <li>Gen_Female</li>
</ol>

<details>
    <summary style=display:list-item;cursor:pointer>
        <strong>Levels</strong>:
    </summary>
    <ol class=list-inline>
        <li>&#39;Gen_Male&#39;</li>
        <li>&#39;Gen_Female&#39;</li>
    </ol>
</details>


<pre><code>Gen_Male Gen_Female Gen_Female Gen_Male Gen_Female
 Levels:
&#39;Gen_Male&#39; &#39;Gen_Female&#39;
</code></pre><p>The above code gives the output where the name is changed for &quot;Male&quot; to &quot;Gen_Male&quot; and &quot;Female&quot; to &quot;Gen_Female&quot;.</p>
<h3 id="ordering-a-categorical-variable">Ordering a Categorical Variable</h3>
<p>Let&#39;s look at a different example when dealing with ordinal categorical values where ordered matters. For instance, for the size of a pant, there might be a size which is considered as Large as &quot;L&quot;, Extra Large as &quot;XL&quot; and Extra extra Large as &quot;XXL&quot; is arranged in ascending order.
The code below contains the collection of vector input of characters &quot;L&quot;, &quot;XL&quot; and &quot;XXL&quot; and stored to &#39;pant&#39;.
&#39;pant.factor&#39; is the variable which has parameter containing levels arranged in ascending order as &#39;levels = c(&quot;L&quot;, &quot;XL&quot;, &quot;XXL&quot;)&#39; and finally &#39;ordered = TRUE&#39;, which makes the sorting possible according to your need.</p>
<pre><code class="lang-python">pant &lt;- c(&quot;XL&quot;,&quot;L&quot;,&quot;XL&quot;,&quot;XXL&quot;,&quot;L&quot;,&quot;XL&quot;)
pant.factor &lt;- factor(pant,ordered = TRUE,levels = c(&quot;L&quot;,&quot;XL&quot;,&quot;XXL&quot;))
pant.factor
pant.factor[1] &gt; pant.factor[2]
</code></pre>
<ol class=list-inline>
    <li>XL</li>
    <li>L</li>
    <li>XL</li>
    <li>XXL</li>
    <li>L</li>
    <li>XL</li>
</ol>

<details>
    <summary style=display:list-item;cursor:pointer>
        <strong>Levels</strong>:
    </summary>
    <ol class=list-inline>
        <li>&#39;L&#39;</li>
        <li>&#39;XL&#39;</li>
        <li>&#39;XXL&#39;</li>
    </ol>
</details>



<p>TRUE</p>
<pre><code>XL L XL XXL L XL
 Levels:&#39;L&#39;&lt; &#39;XL&#39; &lt; &#39;XXL&#39;
TRUE
</code></pre><p>The above output shows the normal output at first where all the vector values (XL, L, XL, XXL, L, XL) are printed out by using &#39;pant.factor&#39;. The levels of vector values &#39;L&#39; &lt; &#39;XL&#39; &lt; &#39;XXL&#39; are arranged in the ascending order, which is printed at the console. Also, &#39;pant.factor[1] &gt; pant.factor[2]&#39; compares whether &quot;XL&quot; is greater than &quot;L&quot;, which results in TRUE being printed.</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 the factor function in R, along with an example, and its structure, order levels, renaming of the levels, and finally, with the ordering of categorical values.</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/factors-in-r

Learn about the factor function in R, along with an example, and it's structure, order levels, renaming of the levels, and finally, with the ordering of categorical values.

(Tutorial) Factors in R

Factors in R

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

<p>The &#39;ifelse()&#39; function is the alternative and shorthand form of the R if-else statement. Also, it uses the &#39;vectorized&#39; technique, which makes the operation faster. All of the vector values are taken as an argument at once rather than taking individual values as an argument multiple times.</p>
<h3 id="syntax">Syntax</h3>
<p>The syntax of &#39;ifelse()&#39; function in R is done by:<br>
<b>ifelse(logical_expression, a , b)</b><br></p>
<p>The argument above in &#39;ifelse&#39; states that:<br>
    1.<b>logical_expression:</b> Indicates an input vector, which in turn will return the vector of the same size as output.<br>
    2.<b> a:</b> Executes when the logical_expression is TRUE.<br>
    3.<b> b:</b> Executes when the logical_expression is FALSE.</p>
<h3 id="example-odd-or-even-">Example (Odd or Even)</h3>
<p>Let&#39;s quickly look at an example below where the following code will check whether numbers are odd or even.
&#39;v&#39; is the vector which consists of a list of numbers. In &#39;ifelse&#39; function the expression &#39;v%%2==1&#39; checks the remainder of each number in the &#39;v&#39; to be one and happens to be TRUE will print &quot;odd&quot; otherwise in FALSE will print &quot;even&quot;.</p>
<pre><code class="lang-python">v = c(14,7,6,9,2)
ifelse(v %% 2 == 1,&quot;odd&quot;,&quot;even&quot;)
</code></pre>
<ol class=list-inline>
    <li>&#39;even&#39;</li>
    <li>&#39;odd&#39;</li>
    <li>&#39;even&#39;</li>
    <li>&#39;odd&#39;</li>
    <li>&#39;even&#39;</li>
</ol>



<p>The above code gives the output as:<br>
<b>&#39;even&#39; &#39;odd&#39; &#39;even&#39; &#39;odd&#39; &#39;even&#39;</b><br>
The internal working of code above produces a logical vector as c(FALSE,TRUE,FALSE,TRUE,FALSE). The first parameter will form a string vector of c(&quot;odd&quot;,&quot;odd&quot;,&quot;odd&quot;,&quot;odd&quot;,&quot;odd&quot;) also the second parameter which in turn will produce string vector as c(&quot;even&#39;,&quot;even&quot;,&quot;even&quot;,&quot;even&quot;,&quot;even&quot;). Finally when the individual vector elements is TRUE gets change to &#39;odd&#39; whereas the &#39;FALSE&#39; will change to &#39;even&#39;.</p>
<h3 id="example-pass-or-fail-">Example(Pass or Fail)</h3>
<p>The example below demonstrates the use of &#39;ifelse()&#39; function along with the use of a DataFrame. If Student scores marks above 40, then he/she may be considered &#39;Pass&#39; otherwise considered &#39;Fail&#39; in an exam.</p>
<p>Let&#39;s quickly create a Data Frame where there is a name of a student as &quot;Student&quot; column with vector as input containing (&quot;Ron&quot;, &quot;Jake&quot;, &quot;Ava&quot;, &quot;Sophia&quot;, &quot;Mia&quot;). Another column is &quot;Marks&quot;, which contains a vector input with the value as (35,75,45,30,85). Finally, both columns are combined to form data frames and store to &#39;x&#39;.</p>
<pre><code class="lang-python">x &lt;- data.frame(&quot;Student&quot; = c(&quot;Ron&quot;,&quot;Jake&quot;,&quot;Ava&quot;,&quot;Sophia&quot;,&quot;Mia&quot;),&quot;Marks&quot; = c(35,75,45,30,85))
str(x)
</code></pre>
<pre><code>&#39;data.frame&#39;:    5 obs. of  2 variables:
 $ Student: Factor w/ 5 levels &quot;Ava&quot;,&quot;Jake&quot;,&quot;Mia&quot;,..: 4 2 1 5 3
 $ Marks  : num  35 75 45 30 85
</code></pre><pre><code>&#39;data.frame&#39;:    5 obs. of  2 variables:
 $ Student: Factor w/ 5 levels &quot;Ava&quot;,&quot;Jake&quot;,&quot;Mia&quot;,..: 4 2 1 5 3
 $ Marks  : num  35 75 45 30 85
</code></pre><p>The above code shows the structure of a Data Frame using the &#39;str(x)&#39; where it says there are 5 observations with 2 variables with the respective values of Student and Marks printed out.</p>
<pre><code class="lang-python">x$Result = ifelse(x$&quot;Marks&quot;&gt;40,&quot;Pass&quot;,&quot;Fail&quot;)
print(x)
</code></pre>
<p>The above code gives the output as below:</p>
<pre><code>    Student Marks Result
1    Ron    35   Fail
2   Jake    75   Pass
3    Ava    45   Pass
4 Sophia    30   Fail
5    Mia    85   Pass
</code></pre><p>The above code has <code>&#39;x$Result&#39;</code> as a variable is used to add a new column &#39;Result&#39; in a Data Frame. The &#39;ifelse()&#39; function has an expression as <code>&#39;x$&quot;Marks&quot;&gt;40&#39;</code>, which checks the vector values from Marks and decides the &#39;Result&#39; to be &#39;Pass&#39; when Marks is greater than 40 otherwise the &#39;Result&#39; is &#39;Fail&#39;.</p>
<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 ifelse() function with is syntax along with it&#39;s help in finding whether a number is Odd or Even and finally with its example to see whether a student is Pass or Fail in an exam.</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/if-else-function-r

Learn in detail about the ifelse() function, including syntax, along with finding whether a number is odd or even, and finally, with an example to see whether a student passed or failed their exam.

(Tutorial) IF ELSE Function  in R

IF ELSE Function  in R

https://www.datacamp.com/community/tutorials/cnn-tensorflow-python

In this tutorial, you'll learn how to construct and implement Convolutional Neural Networks (CNNs) in Python with the TensorFlow framework.

(Tutorial) Convolutional Neural Networks with TensorFlow

Convolutional Neural Networks with TensorFlow

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.

(Tutorial) Recommender Systems in Python

Beginner Tutorial: Recommender Systems in Python

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

Learn how to read and write data into flat files, such as CSV, JSON, text files, and binary files in Python using io and os modules.

(Tutorial) Reading and Writing 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.

(Tutorial) Python Excel: The Definitive Guide

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.

(Tutorial) Scope of Variables in Python

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.

community

datacamp

Tutorials