https://www.datacamp.com/community/tutorials/generate-data-trumania

Discover Python Trumania, a scenario-based random dataset generator library. Learn how to generate a synthetic and random dataset in this step-by-step tutorial. 

Step-by-step tutorial to use Python Trumania a random dataset generator. Learn how to generate synthetic datasets today!

Python Code to Generate Synthetic & Random Dataset with Trumania

Generating Realistic Random Datasets with Trumania

<p>54% of the respondents from the&nbsp;<a href="http://www.oreilly.com/data/free/2016-data-science-salary-survey.csp">O&#39;Reilly Data Science Salary Survey</a>&nbsp;indicated that they used Python as a data science tool. Nobody can deny that Python has been on the rise in the data science industry&nbsp;and it certainly seems that it&#39;s here to stay.</p>

<p>This rise in popularity in the industry, the long gone infancy of Python packages for data analysis, the low and gradual learning curve and the fact that it is a&nbsp;fully fledged programming language are only a couple of reasons that make Python an exceptional tool for data science.</p>

<p>Although Python is a very readable language, you might still be able to use some help.</p>

<p>That&#39;s enough reason for DataCamp to make a Python cheat sheet for data science, especially&nbsp;for&nbsp;beginners. It&nbsp;can serve as a quick reference for those of you who are just beginning their&nbsp;data science journey or it can serve as a guide to make it easier to learn about and use Python.</p>

<p>This cheat sheet is free additional material that complements DataCamp&#39;s&nbsp;<a href="https://www.datacamp.com/courses/intro-to-python-for-data-science/">Intro to Python for Data Science course</a>, where you learn by doing.</p>

<p><a href="http://datacamp-community-prod.s3.amazonaws.com/0eff0330-e87d-4c34-88d5-73e80cb955f2" target="_blank"><img alt="Python For Data Science Cheat Sheet For Beginners" src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1620781328/Python_For_Data_Science_-_A_Cheat_Sheet_For_Beginners_igzrny.png" /></a></p>

<p><strong>(Above is the printable version of this cheat sheet)</strong></p>

<br>

<p>This Python cheat sheet will guide you through variables and data types, Strings, Lists, to eventually land at the fundamental package for scientific computing with Python, Numpy.</p>

<div id="scoped-content">
<style type="text/css">:target:before {
content:"";
display:block;
height:150px;
margin:-150px 0 0;
}

h3 {font-weight:normal;
}
h4 {
	font-weight: lighter;
}
table {
    width: 100%;
    table-layout: fixed;
}
td {color: black; font-size: 16px; padding-top: 2px }
th {
    height: 50px;
}
th, td {
		padding: 1.5px;
    text-align: left;}
tr:hover {background-color: #f5f5f5}
</style>
<h2>Install Python</h2>
<a href="https://www.continuum.io/downloads">Download Anaconda</a>

<h2>Libraries</h2>

<h3>Import libraries</h3>

<table>
	<tbody>
		<tr>
			<td><code>import numpy</code></td>
		</tr>
		<tr>
			<td><code>import numpy as np</code></td>
		</tr>
	</tbody>
</table>

<h3>Selective import</h3>

<table>
	<tbody>
		<tr>
			<td><code>from math import pi</code></td>
		</tr>
	</tbody>
</table>

<h2>Asking for Help</h2>

<table>
	<tbody>
		<tr>
			<td><code>&gt;&gt;&gt; help(str)</code></td>
		</tr>
	</tbody>
</table>

<h2>Variables and Data Types</h2>

<h3>Variable Assignment</h3>

<table>
	<tbody>
		<tr>
			<td><code>&gt;&gt;&gt; x=5</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; x</code></td>
		</tr>
		<tr>
			<td><code>5</code></td>
		</tr>
	</tbody>
</table>

<h3>Calculations With Variables</h3>

<table>
	<tbody>
		<tr>
			<td>Sum of two variables</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; x+2</code></td>
		</tr>
		<tr>
			<td><code>7</code></td>
		</tr>
		<tr>
			<td>Subtraction of two variables</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; x-2</code></td>
		</tr>
		<tr>
			<td><code>3</code></td>
		</tr>
		<tr>
			<td>Multiplication of two variables</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; x*2 </code></td>
		</tr>
		<tr>
			<td><code>10</code></td>
		</tr>
		<tr>
			<td>Exponentiation of a variable</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; x**2</code></td>
		</tr>
		<tr>
			<td><code>25</code></td>
		</tr>
		<tr>
			<td>Remainder of a variable</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; x%2</code></td>
		</tr>
		<tr>
			<td><code>1</code></td>
		</tr>
		<tr>
			<td>Division of a variable</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; x/float(2)</code></td>
		</tr>
		<tr>
			<td><code>2.5</code></td>
		</tr>
	</tbody>
</table>

<h3>Types and Type Conversion</h3>

<table>
	<tbody>
		<tr>
			<td>Variables to strings</td>
		</tr>
		<tr>
			<td><code>str()</code></td>
		</tr>
		<tr>
			<td><code>&#39;5&#39;, &#39;3.45&#39;, &#39;True&#39;</code></td>
		</tr>
		<tr>
			<td>Variables to integers</td>
		</tr>
		<tr>
			<td><code>int()</code></td>
		</tr>
		<tr>
			<td><code>5, 3, 1</code></td>
		</tr>
		<tr>
			<td>Variables to floats</td>
		</tr>
		<tr>
			<td><code>float()</code></td>
		</tr>
		<tr>
			<td><code>5.0, 1.0</code></td>
		</tr>
		<tr>
			<td>Variables to booleans</td>
		</tr>
		<tr>
			<td><code>bool()</code></td>
		</tr>
		<tr>
			<td><code>True, True, True</code></td>
		</tr>
	</tbody>
</table>

<h2>Strings</h2>

<table>
	<tbody>
		<tr>
			<td><code>&gt;&gt;&gt; my_string = &#39;thisStringIsAwesome&#39;</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_string</code></td>
		</tr>
		<tr>
			<td><code>&#39;thisStringIsAwesome&#39;</code></td>
		</tr>
	</tbody>
</table>

<h3>String Operations</h3>

<table>
	<tbody>
		<tr>
			<td><code>&gt;&gt;&gt; my_string * 2</code></td>
		</tr>
		<tr>
			<td><code>&#39;thisStringIsAwesomethisStringIsAwesome&#39;</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_string + &#39;Innit&#39;</code></td>
		</tr>
		<tr>
			<td><code>&#39;thisStringIsAwesomeInnit&#39;</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; &#39;m&#39; in my_string</code></td>
		</tr>
		<tr>
			<td><code>&#39;True&#39;</code></td>
		</tr>
	</tbody>
</table>

<h3>Selecting String Characters</h3>



<table>
	<tbody>
		<tr>
			<td><code>&gt;&gt;&gt; my_string[3]</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_string[4:9]</code></td>
		</tr>
	</tbody>
</table>

<h3>String Methods</h3>

<table>
	<tbody>
		<tr>
			<td>String to uppercase</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_string.upper()</code></td>
		</tr>
		<tr>
			<td>String to lowercase</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_string.lower()</code></td>
		</tr>
		<tr>
			<td>Count String elements</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_string.count(&#39;w&#39;)</code></td>
		</tr>
		<tr>
			<td>Replace String elements</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_string.replace(&#39;e&#39;, &#39;i&#39;)</code></td>
		</tr>
		<tr>
			<td>Strip whitespace from ends</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_string.strip()</code></td>
		</tr>
	</tbody>
</table>

<h2>Lists</h2>

<table>
	<tbody>
		<tr>
			<td><code>&gt;&gt;&gt; a = &#39;is&#39;</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; b = &#39;nice&#39;</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list = [&#39;my&#39;, &#39;list&#39;, a, b]</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list2 = [[4,5,6,7], [3,4,5,6]]</code></td>
		</tr>
	</tbody>
</table>

<h3>Selecting List Elements</h3>


Subset

<table>
	<tbody>
		<tr>
			<td>Select item at index 1</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list[1]</code></td>
		</tr>
		<tr>
			<td>Select 3rd last item</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list[-3]</code></td>
		</tr>
	</tbody>
</table>

<h4>Slice</h4>

<table>
	<tbody>
		<tr>
			<td>Select items at index 1 and 2</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list[1:3]</code></td>
		</tr>
		<tr>
			<td>Select items after index 0</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list[1:]</code></td>
		</tr>
		<tr>
			<td>Select items before index 3</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list[:3]</code></td>
		</tr>
		<tr>
			<td>Copy my_list</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list[:]</code></td>
		</tr>
	</tbody>
</table>

<h4>Subset Lists of Lists</h4>

<table>
	<tbody>
		<tr>
			<td>my_list[list][itemOfList]</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list2[1][0]</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list2[1][:2]</code></td>
		</tr>
	</tbody>
</table>

<h3>Lists Operations</h3>

<table>
	<tbody>
		<tr>
			<td><code>&gt;&gt;&gt; my_list + my_list</code></td>
		</tr>
		<tr>
			<td><code>[&#39;my&#39;, &#39;list&#39;, &#39;is&#39;, &#39;nice&#39;, &#39;my&#39;, &#39;list&#39;, &#39;is&#39;, &#39;nice&#39;]</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list * 2</code></td>
		</tr>
		<tr>
			<td><code>[&#39;my&#39;, &#39;list&#39;, &#39;is&#39;, &#39;nice&#39;, &#39;my&#39;, &#39;list&#39;, &#39;is&#39;, &#39;nice&#39;]</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list2 &gt; 4</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; True</code></td>
		</tr>
	</tbody>
</table>

<h3>List Methods</h3>

<table>
	<tbody>
		<tr>
			<td>Get the index of an item</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list.index(a)</code></td>
		</tr>
		<tr>
			<td>Count an item</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list.count(a)</code></td>
		</tr>
		<tr>
			<td>Append an item at a time</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list.append(&#39;!&#39;)</code></td>
		</tr>
		<tr>
			<td>Remove an item</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list.remove(&#39;!&#39;)</code></td>
		</tr>
		<tr>
			<td>Remove an item</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; del(my_list[0:1])</code></td>
		</tr>
		<tr>
			<td>Reverse the list</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list.reverse()</code></td>
		</tr>
		<tr>
			<td>Append an item</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list.extend(&#39;!&#39;)</code></td>
		</tr>
		<tr>
			<td>Remove an item</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list.pop(-1)</code></td>
		</tr>
		<tr>
			<td>Insert an item</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list.insert(0,&#39;!&#39;)</code></td>
		</tr>
		<tr>
			<td>Sort the list</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_list.sort()</code></td>
		</tr>
	</tbody>
</table>

<h2>Numpy Arrays</h2>

<table>
	<tbody>
		<tr>
			<td><code>&gt;&gt;&gt; my_list = [1, 2, 3, 4]</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_array = np.array(my_list)</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_2darray = np.array([[1,2,3],[4,5,6]])</code></td>
		</tr>
	</tbody>
</table>

<h3>Selecting Numpy Array Elements</h3>



<h4>Subset</h4>

<table>
	<tbody>
		<tr>
			<td>Select item at index 1</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_array[1]</code></td>
		</tr>
		<tr>
			<td><code>2</code></td>
		</tr>
	</tbody>
</table>

<h4>Slice</h4>

<table>
	<tbody>
		<tr>
			<td>Select items at index 0 and 1</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_array[0:2]</code></td>
		</tr>
		<tr>
			<td><code>array([1, 2])</code></td>
		</tr>
	</tbody>
</table>

<h4>Subset 2D Numpy arrays</h4>

<table>
	<tbody>
		<tr>
			<td>my_2darray[rows, columns]</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_2darray[:,0]</code></td>
		</tr>
		<tr>
			<td><code>array([1, 4])</code></td>
		</tr>
	</tbody>
</table>

<h4>Numpy Array Operations</h4>

<table>
	<tbody>
		<tr>
			<td><code>&gt;&gt;&gt; my_array &gt; 3</code></td>
		</tr>
		<tr>
			<td><code>array([False, False, False, True], dtype=bool)</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_array * 2</code></td>
		</tr>
		<tr>
			<td><code>array([2, 4, 6, 8])</code></td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_array + np.array([5, 6, 7, 8])</code></td>
		</tr>
		<tr>
			<td><code>array([6, 8, 10, 12])])</code></td>
		</tr>
	</tbody>
</table>

<h4>Numpy Array Functions</h4>

<table>
	<tbody>
		<tr>
			<td>Get the dimensions of the array</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_array.shape</code></td>
		</tr>
		<tr>
			<td>Append items to an array</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; np.append(other_array)</code></td>
		</tr>
		<tr>
			<td>Insert items in an array</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; np.insert(my_array, 1, 5)</code></td>
		</tr>
		<tr>
			<td>Delete items in an array</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; np.delete(my_array,[1])</code></td>
		</tr>
		<tr>
			<td>Mean of the array</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; np.mean(my_array)</code></td>
		</tr>
		<tr>
			<td>Median of the array</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; np.median(my_array)</code></td>
		</tr>
		<tr>
			<td>Correlation coefficient</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; my_array.corrcoef()</code></td>
		</tr>
		<tr>
			<td>Standard deviation</td>
		</tr>
		<tr>
			<td><code>&gt;&gt;&gt; np.std(my_array)</code></td>
		</tr>
	</tbody>
</table>

<h2>To download this cheat sheet, click below</h2>

<p><a href="http://datacamp-community-prod.s3.amazonaws.com/0eff0330-e87d-4c34-88d5-73e80cb955f2" target="_blank"><img alt="Python For Data Science Cheat Sheet For Beginners" src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1620781328/Python_For_Data_Science_-_A_Cheat_Sheet_For_Beginners_igzrny.png" /></a></p>

<p>If you&#39;re interested in more cheat sheets, check out our <a href="https://www.datacamp.com/community/blog/bokeh-cheat-sheet-python/">Bokeh cheat sheet</a> for data visualization in Python and our&nbsp;<a href="https://www.datacamp.com/community/blog/python-pandas-cheat-sheet/">Pandas cheat sheet</a> for data manipulation in Python.&nbsp;</p>

<p>Do you want to learn more? Complete the <a href="https://www.datacamp.com/courses/intro-to-python-for-data-science/">Intro to Python for Data Science course</a>&nbsp;today!&nbsp;</p>
</div>


https://www.datacamp.com/community/tutorials/python-data-science-cheat-sheet-basics

This handy one-page reference presents the Python basics that you need to do data science

Python For Data Science - A Cheat Sheet For Beginners

<h2 id="what-is-a-jupyter-notebook-">What is a Jupyter Notebook?</h2>
<p>&#39;Jupyter&#39; is an acronym meaning Julia, Python, and R. These programming languages were the original use case for Jupyter. Now though, Jupyter Notebook supports many other languages (Source: <a href="https://medium.com/@blessedmarcel1/how-to-install-jupyter-notebook-on-mac-using-homebrew-528c39fd530f">How to install Jupyter Notebook on Mac using Homebrew</a>).</p>
<p>The main components of the whole environment are, on the one hand, the notebooks themselves and the application. On the other hand, you also have a notebook kernel and a notebook dashboard.</p>
<p>&quot;&#39;notebook&#39; denotes documents that contain both code and rich text elements, such as figures, links, equations, etc. Because of the mix of code and text elements, these documents are the ideal place to bring together an analysis description and its results. They also can be executed to perform the data analysis in real-time&quot; —<a href="https://medium.com/@blessedmarcel1/how-to-install-jupyter-notebook-on-mac-using-homebrew-528c39fd530f">How to install Jupyter Notebook on Mac using Homebrew</a>.</p>
<p>Let&#39;s look at these components in more detail.</p>
<h3 id="what-is-the-jupyter-notebook-app-">What is the Jupyter Notebook App?</h3>
<p>As a server-client application, the Jupyter Notebook App allows you to edit and run your notebooks via a web browser. The application can be executed on a PC without Internet access, or it can be installed on a remote server, where you can access it through the Internet.</p>
<h2 id="advantages-of-a-jupyter-notebook">Advantages of a Jupyter Notebook</h2>
<ul>
<li><p>Notebook has the ability to re-run individual code snippets, and it provides you the flexibility of modifying them before re-running.</p>
</li>
<li><p>You can deploy a Jupyter Notebook on a remote server and access it from your local web browser.</p>
</li>
<li><p>You can insert notes and documentation to your code in a Jupyter Notebook in various formats like markdown, latex, and HTML.</p>
</li>
<li><p>Headings in a Jupyter Notebook are also supported, which is very useful when you want to provide heading &amp; sub-heading to signify various important parts of your codebase. It helps improve the readers&#39; experience.</p>
</li>
<li><p>Use a Jupyter Notebook as cells.</p>
</li>
<li><p>Ability to share a Jupyter Notebook in various formats like <code>.py</code>, <code>.html</code>, <code>.md</code>, <code>.pdf</code>, etc.</p>
</li>
<li><p>For <em>machine learning</em> folks, Jupyter Notebook is very helpful since it allows for Data Visualization. Jupyter Notebook supports visualizations and enables you to render graphs and charts. These are generated from codes with the help of modules like Matplotlib, Plotly, or Bokeh.</p>
</li>
</ul>
<h2 id="how-to-install-the-notebook-using-pip-">How to Install the Notebook Using <code>pip</code></h2>
<p>If you don&#39;t want to install Anaconda, you just have to make sure that you have the latest version of <code>pip</code>. If you have installed Python, you will typically already have it.</p>
<p>What you do need to do is upgrade <code>pip</code> but before, that let&#39;s install and create a virtual environment:</p>
<pre><code class="lang-python"># On OS X or Linux
pip3 install virtualenv
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465233/jup1_woihqi.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<p>Now let&#39;s create a virtual environment <code>jupyter</code> and activate it!</p>
<pre><code class="lang-python">virtualenv jupyter
source jupyter/bin/activate
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465231/jup2_a5yndv.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<p>Let&#39;s upgrade <code>pip</code> now, but first, let&#39;s check the already installed <code>pip</code> version.</p>
<pre><code class="lang-python">pip3 --version
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465230/jup3_nnffd7.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<p>From the above output, you can see that we have <code>pip</code> version <code>20.2.1</code>.</p>
<p>Let&#39;s upgrade that:</p>
<pre><code class="lang-python"># On Windows
python -m pip install -U pip setuptools
# On OS X or Linux
pip3 install -U pip setuptools
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465231/jup4_qgtyl2.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<p>Once you have <code>pip</code>, you can just run the below command to install a Jupyter Notebook, which would take a while to install.</p>
<pre><code class="lang-python">pip3 install jupyter
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465232/jup5_rgihme.png" alt="Installing Jupyter Notebook">
</figure>
</center>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465232/jup6_cztm0d.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<p>Great! So you are all set to run and start using Jupyter Notebook but before that, let&#39;s also look at how you can install jupyter using Anaconda.</p>
<h2 id="how-to-install-jupyter-notebook-using-anaconda">How to Install Jupyter Notebook Using Anaconda</h2>
<p>One of the requirements here is Python, Python 3.3, or greater since Python 2.7 has reached the end of its life (EOL) on January 1st, 2020. The general recommendation is that you use the Anaconda distribution to install both Python and the Jupyter Notebook.</p>
<p>Jupyter Notebook in Anaconda comes pre-installed, meaning that you do not have to install it explicitly. All you need to install is Anaconda, and Jupyter Notebook would already be present inside it.</p>
<p>Anaconda&#39;s advantage is that you have access to over 720 packages that can easily be installed with Anaconda&#39;s conda, a package, dependency, and environment manager. You can follow the instructions for the installation of Anaconda here for <a href="https://www.datacamp.com/community/tutorials/installing-anaconda-mac-os-x">Mac</a> or <a href="https://www.datacamp.com/community/tutorials/installing-anaconda-windows">Windows</a>.</p>
<p>Is something not clear? You can always read up on the Jupyter installation instructions <a href="https://jupyter.readthedocs.io/en/latest/install.html">here</a>.</p>
<p>If you need more information about installing packages in Python, you can go to <a href="https://packaging.python.org/installing/">this page</a>.</p>
<h2 id="getting-started-with-jupyter-notebook">Getting Started With Jupyter Notebook</h2>
<p>Now that you have learned all about what Jupyter Notebooks are, their benefits, and how to install them on your machines, let&#39;s put them to some practical use!</p>
<h3 id="launching-jupyter-notebook">Launching Jupyter Notebook</h3>
<p>To launch your Jupyter notebook, simply type the below command!</p>
<pre><code class="lang-python">jupyter notebook
</code></pre>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465232/jup7_hsg0fi.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<p>Once you do this, the Jupyter notebook should open up the below tab for you inside your web browser:</p>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465231/jup9_rv1uc2.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<p>Note that the Jupyter Notebook will open using the below URL:</p>
<p><a href="http://localhost:8888/tree">http://localhost:8888/tree</a></p>
<p>However, the port number <code>8888</code> might change if a process is using it or a second Jupyter Notebook session runs in the background.</p>
<p>In some cases, the Jupyter Notebook might not open up on its own, in which case you can simply copy one of the URLs that are generated when you run the command <code>jupyter notebook</code>, which in our case is:</p>
<p><a href="http://localhost:8889/?token=e41173caeda552cdcab1bcc775e2463ac510b8847f73604b">http://localhost:8889/?token=e41173caeda552cdcab1bcc775e2463ac510b8847f73604b</a></p>
<p>Now, let&#39;s open a Python3 Notebook inside Jupyter by clicking the <code>New</code> tab and select <code>Python3</code>:</p>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465231/jup10_mthrq0.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<p>And finally, we have our very first Python3 Jupyter Notebook:</p>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465232/jup11_pfmhbo.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<h3 id="adding-heading-and-notes-in-jupyter-notebook">Adding Heading and Notes in Jupyter Notebook</h3>
<p>In the drop-down menu shown below, you have four options:</p>
<ul>
<li><strong>Code</strong> – In the code cell, you write the Python code.</li>
</ul>
<ul>
<li><strong>Markdown</strong> – In this cell type, you can add headings, notes, documentation, etc.</li>
</ul>
<ul>
<li><strong>Raw NBConvert</strong> – This cell type can be used to render different code formats into HTML or LaTeX. This information is stored in the notebook metadata and converted appropriately.</li>
</ul>
<p>Let&#39;s look at the <code>markdown</code> example for adding headings and bullet points:</p>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465232/jup12_gki9jz.png" alt="Installing Jupyter Notebook">
</figure>
</center>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465233/jup13_njmhvx.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<h3 id="sharing-a-jupyter-notebook">Sharing a Jupyter Notebook</h3>
<p>This is one of the great and cool features of a Jupyter Notebook.</p>
<p>Go to the <code>Files</code> menu, and you’ll see a <code>Download As</code> option where you can download the Jupyter Notebook in almost nine different ways. The most commonly used is either a <code>.ipynb</code> or <code>.py</code> file:</p>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465232/jup14_v2gzvf.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<h3 id="installing-a-python-module-in-jupyter-notebook">Installing a Python Module in Jupyter Notebook</h3>
<p>Installing a Python module inside Jupyter Notebook is as easy as installing it from the terminal. All you need to do is use an <code>!</code>(exclamation) mark at the start of the command, as shown below:</p>
<center>
<figure>
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603465233/jup15_prcdrd.png" alt="Installing Jupyter Notebook">
</figure>
</center>

<h3 id="writing-a-python-function-in-jupyter-notebook">Writing a Python Function in Jupyter Notebook</h3>
<p>Let&#39;s write a Python function that generates random integers between 0 and 100 five times, and each time the size of the vector increments by one.</p>
<p>First, let&#39;s import <code>numpy</code>.</p>
<pre><code class="lang-python">import numpy as np
</code></pre>
<p>Next, the <a href="https://www.datacamp.com/community/tutorials/numpy-random"><code>random</code> function</a> which takes two inputs, <code>low</code> and <code>size</code> of the array, and finally returns the <code>num</code>.</p>
<pre><code class="lang-python">def random(low, size):
    num = np.random.randint(low=low ,size=size)
    return num
</code></pre>
<pre><code class="lang-python">for i in range(5):
    print(random(100, i+1))
</code></pre>
<pre><code>[80]
[19 89]
[66 72 77]
[41 55 82 10]
[95 90 53 99 46]
</code></pre><h1 id="conclusion">Conclusion</h1>
<p>In this Jupyter Notebook tutorial, you were introduced to its advantages. You further learned how to install Jupyter Notebook using <code>pip</code> and Anaconda. Finally, we covered a few practical use-cases like how to make headings, write python code, and how to share a Jupyter Notebook.</p>
<p>To learn more about Jupyter Notebook, please check out this complete comprehensive tutorial <a href="https://www.datacamp.com/community/tutorials/tutorial-jupyter-notebook#WhatIs">Jupyter Notebook Tutorial: The Definitive Guide</a>.</p>


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

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

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

Installing Jupyter Notebook

<p>Data visualization is an essential skill for data scientists. It combines statistics and design in meaningful and appropriate ways. On the one hand, data visualization is a form of graphical data analysis, emphasizing accurate representation, and data interpretation. On the other hand, data visualization relies on good design choices to make our plots attractive and aid both the understanding and communication of results. On top of that, there is an element of creativity, since data visualization is a form of visual communication at its heart.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/c_scale,f_auto,q_auto:best,w_400/v1601047315/Screen_Shot_2020-09-25_at_11.19.09_AM_mufbol.png" /></center>

<p>It&#39;s important to understand the distinction between exploratory and explanatory visualizations. Exploratory visualizations are easily-generated, data-heavy, and intended for a small specialist audience, such as yourself and your colleagues - their primary purpose is graphical data analysis. Explanatory visualizations are labor-intensive, data-specific, and intended for a broader audience, e.g., in publications or presentations - they are part of the communications process. As a data scientist, it&#39;s essential that you can quickly explore data, but you&#39;ll also be tasked with explaining your results to stake-holders. Good design begins with thinking about the audience - and sometimes that just means ourselves.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1601047315/Screen_Shot_2020-09-25_at_11.19.25_AM_xcki8p.png" /></center>

<h2 id="scatter-plot">Scatter Plot</h2>
<p>Below, we have a dataset that contains the average brain and body weights of 62 mammals.</p>
<pre><code>MASS::mammals
</code></pre><pre><code>                              body   brain
Arctic fox                   3.385   44.50
Owl monkey                   0.480   15.50
Mountain beaver              1.350    8.10
Cow                        465.000  423.00
Grey wolf                   36.330  119.50
Goat                        27.660  115.00
Roe deer                    14.830   98.20
...
Pig                        192.000  180.00
Echidna                      3.000   25.00
Brazilian tapir            160.000  169.00
Tenrec                       0.900    2.60
Phalanger                    1.620   11.40
Tree shrew                   0.104    2.50
Red fox                      4.235   50.40
</code></pre><p>To understand the relationship here, the most obvious first step is to make a scatter plot, like the one shown below:</p>
<pre><code class="lang-r">ggplot(mammals, aes(x = body, y = brain)) +
  geom_point()
</code></pre>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/c_scale,f_auto,q_auto:best,w_400/v1601047315/Screen_Shot_2020-09-25_at_11.19.41_AM_psxeu9.png" /></center>

<p>Two mammals, the African and the Asian Elephants have both very large brain and body weights, leading to a positive skew on both axes.</p>
<h2 id="linear-model">Linear Model</h2>
<p>Now, if we were to apply a linear model, it would be a poor choice since a few extreme values have a large influence.</p>
<pre><code class="lang-r">ggplot(mammals, aes(x = body, y = brain)) +
  geom_point(alpha = 0.6) +
  stat_smooth(
    method = &quot;lm&quot;,
    color = &quot;red&quot;,
    se = FALSE
  )
</code></pre>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/c_scale,f_auto,q_auto:best,w_400/v1601047315/Screen_Shot_2020-09-25_at_11.19.52_AM_sduhm8.png" /></center>

<p>Applying a log transformation of both variables allows for a better fit.</p>
<pre><code>ggplot(mammals, aes(x = body, y = brain)) +
  geom_point(alpha = 0.6) +
  coord_fixed() +
  scale_x_log10() +
  scale_y_log10() +
  stat_smooth(
    method = &quot;lm&quot;,
    color = &quot;#C42126&quot;,
    se = FALSE,
    size = 1
  )
</code></pre><center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/c_scale,f_auto,q_auto:best,w_400/v1601047315/Screen_Shot_2020-09-25_at_11.20.10_AM_mkqjpw.png" /></center>


<p>So, although we began with a rough exploratory plot, it informed us about our data and led us to a meaningful result.</p>
<h3 id="anscombe-s-plots">Anscombe&#39;s Plots</h3>
<p>When we imagine a linear model, as presented on this anonymous plot, we imagine that we are describing data that looks something like this.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/c_scale,f_auto,q_auto:best,w_400/v1601047784/Screen_Shot_2020-09-25_at_11.29.23_AM_n4rynf.png" /></center>

<p>But this same model could be describing a very different set of data, such as a parabolic relationship, which calls for a different model.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best,w_400/v1601047791/Screen_Shot_2020-09-25_at_11.29.30_AM_yondtv.png" /></center>

<p>Or data in which an extreme value has a large effect. which becomes clear when the outlier is removed.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best,w_400/v1601048085/Screen_Shot_2020-09-25_at_11.34.30_AM_y0cqcq.png" /></center>

<p>And sometimes, the model may be describing a relationship where, in fact, there is none at all because some extreme values may be incorrect.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best,w_400/v1601048272/Screen_Shot_2020-09-25_at_11.37.23_AM_fiuxww.png" /></center>

<p>If we relied solely on the numerical output without plotting our data, we&#39;d have missed distinct and interesting underlying trends.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1601048272/Screen_Shot_2020-09-25_at_11.37.38_AM_ohqkck.png" /></center>

<p>We can see that data visualization is rooted in statistics and graphical data analysis, but it&#39;s also a creative process that involves some amount of trial and error.</p>
<h2 id="interactive-example">Interactive Example</h2>
<p>In the following example, you will first Load the <code>ggplot2</code> package using <a href="http://www.rdocumentation.org/packages/base/functions/library">library()</a>. Then, you will use <a href="http://www.rdocumentation.org/packages/utils/functions/str">str()</a> to explore the structure of the <code>mtcars</code> dataset.</p>
<p>Finally, you will visualize the ggplot and try to understand what ggplot does with the data.</p>
<p>You will use the <code>mtcars</code> dataset contains information on 32 cars from a 1973 issue of Motor Trend magazine. This dataset is small, intuitive, and contains a variety of continuous and categorical variables.</p>
<pre><code class="lang-python"># Load the ggplot2 package
library(ggplot2)

# Explore the mtcars data frame with str()
str(mtcars)

# Execute the following command
p &lt;- ggplot(mtcars, aes(cyl, mpg)) +
  geom_point()
</code></pre>
<p>When we run the above code, it produces the following result:</p>
<pre><code>data.frame&#39;:    32 obs. of  11 variables:
 $ mpg : num  21 21 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 ...
 $ cyl : num  6 6 4 6 8 6 8 4 4 6 ...
 $ disp: num  160 160 108 258 360 ...
 $ hp  : num  110 110 93 110 175 105 245 62 95 123 ...
 $ drat: num  3.9 3.9 3.85 3.08 3.15 2.76 3.21 3.69 3.92 3.92 ...
 $ wt  : num  2.62 2.88 2.32 3.21 3.44 ...
 $ qsec: num  16.5 17 18.6 19.4 17 ...
 $ vs  : num  0 0 1 1 0 1 0 1 1 1 ...
 $ am  : num  1 1 1 0 0 0 0 0 0 0 ...
 $ gear: num  4 4 4 3 3 3 3 4 4 4 ...
 $ carb: num  4 4 1 1 2 1 4 2 2 4 ...
</code></pre><center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1601049048/ggplot2_au2hht.png" /></center>


<p><a href="https://campus.datacamp.com/courses/introduction-to-data-visualization-with-ggplot2/introduction-c90b4341-2fc9-4d0e-9c57-8d74ae7fae5f?ex=3">Try it for yourself</a>.</p>
<p>To learn more about data visualization with ggplot, please see this video from our course <a href="https://www.datacamp.com/courses/introduction-to-data-visualization-with-ggplot2/introduction-c90b4341-2fc9-4d0e-9c57-8d74ae7fae5f?ex=1">Introduction to Data Visualization with ggplot2</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/K8Al2CEd_6k?start=17" frameborder="0" allow="accelerometer; autoplay; clipboard-write; 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-data-visualization-with-ggplot2">Introduction to Data Visualization with ggplot2</a> course by Rick Scavetta.</p>


https://www.datacamp.com/community/tutorials/graphics-with-ggplot2

(Tutorial) Graphics with ggplot2

Graphics with ggplot2

https://www.datacamp.com/community/tutorials/streaming-platform-analysis

In this Python tutorial, explore movie data of popular streaming platforms and build a recommendation system.

(Tutorial) Recommendation System for Streaming Platforms

Recommendation System for Streaming Platforms

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.

Learn how to construct and implement Convolutional Neural Networks (CNNs) in Python with the TensorFlow framework. Follow our step-by-step tutorial with code examples today!

Python Convolutional Neural Networks (CNN) with TensorFlow Tutorial

Convolutional Neural Networks with TensorFlow

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.

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

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

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

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

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

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



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





<h2 id="removing-variable">Removing Variable</h2>
<p>The variable in R can  easily be removed or deleted by using &#39;rm()&#39;.<br>
For example, the output of the code below is 8.</p>
<pre><code>my.var = 8
cat(my.var)
</code></pre><p>The variable is removed by using &#39;rm(my.var)&#39;.</p>
<pre><code>rm(my.var)
</code></pre><p>You can check whether the variable is removed or not through the help of &#39;cat(my.var)&#39;</p>
<pre><code>cat(my.var)
</code></pre><p>The above code will result in the following error:<br>
<b>Error in cat(my.var): object &#39;my.var&#39; not found</b></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 variables, rules for defining variables, different types of assignment of the variable along with different kinds of checking the variable types, and removal of the variable.</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/variables-in-r

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

(Tutorial) Definitive Guide: Variables in R

Definitive Guide: Variables in R

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

tutorial

on

python

print

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


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

TypeError                                 Traceback (most recent call last)

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


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


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

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

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

(Tutorial) Python Print() Function

Python Print() Function

<p><center><a href="https://s3.amazonaws.com/assets.datacamp.com/email/other/Python+vs+R.pdf"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603467084/Tutorial__R_or_Python_for_Data_Analysis_fkkn9s.png" /></a></center><br></p>
<p>It&#39;s hard to know whether to use Python or R for data analysis. And that’s especially true if you&#39;re a newbie data analyst looking for the right language to start with.</p>
<p>But it is possible to figure out the strengths and weaknesses of both languages. One language isn’t better than the other—it all depends on your use case and the questions you’re trying to answer: What should I use for machine learning? I need a fast solution, so should I use Python or R?
Python vs. R for Data Analysis
At DataCamp, we often get emails from learners asking whether they should use Python or R when performing their day-to-day data analysis tasks. Both Python and R are among the most popular languages for data analysis, and each has its supporters and opponents. While Python is often praised for being a general-purpose language with an easy-to-understand syntax, R&#39;s functionality was developed with statisticians in mind, thereby giving it <a href="http://www.quora.com/Which-is-better-for-data-analysis-R-or-Python">field-specific advantages</a> such as great features for data visualization.</p>
<p>Our infographic &quot;When Should I Use Python vs. R?&quot; is for anyone interested in how these two programming languages compare to each other from a data science and analytics perspective, including their unique strengths and weaknesses. Click the image below to download the infographic and access the embedded links.</p>
<p><center><a href="https://s3.amazonaws.com/assets.datacamp.com/email/other/Python+vs+R.pdf"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603890265/Python_vs_R_zerop6.pdf" /></a></center><br></p>
<p>For additional insight into these languages, read our blog post on <a href="https://www.datacamp.com/community/blog/when-to-use-python-or-r">Python vs. R for Data Science: What’s the Difference?</a> To explore these languages for yourself, try our <a href="https://www.datacamp.com/courses/intro-to-python-for-data-science/">Introduction to Python</a> and <a href="https://www.datacamp.com/courses/free-introduction-to-r/">Introduction to R</a> courses.</p>


https://www.datacamp.com/community/tutorials/r-or-python-for-data-analysis

Wondering whether you should use Python or R for data analysis? You’ve come to the right place. 

Python vs. R. What is the difference between Python and R? Find a fun infographic & see why you should learn Python or R for data science today!

Infographic Python vs. R for Data Analysis?

Choosing Python or R for Data Analysis? An Infographic

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

Learn about Markov Chains, their properties, transition matrices, and implement one yourself in Python!

Learn about Markov Chains and how they can be applied in this tutorial. Build your very own model using Python today!

community

datacamp

Data Science Tutorials