<h2 id="what-is-a-jupyter-notebook-">What is a Jupyter Notebook?</h2>
&#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>).
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.
&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>.
Let&#39;s look at these components in more detail.
<h3 id="what-is-the-jupyter-notebook-app-">What is the Jupyter Notebook App?</h3>
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.
<h2 id="advantages-of-a-jupyter-notebook">Advantages of a Jupyter Notebook</h2>
<ul>
<li>Notebook has the ability to re-run individual code snippets, and it provides you the flexibility of modifying them before re-running.
</li>
<li>You can deploy a Jupyter Notebook on a remote server and access it from your local web browser.
</li>
<li>You can insert notes and documentation to your code in a Jupyter Notebook in various formats like markdown, latex, and HTML.
</li>
<li>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.
</li>
<li>Use a Jupyter Notebook as cells.
</li>
<li>Ability to share a Jupyter Notebook in various formats like <code>.py</code>, <code>.html</code>, <code>.md</code>, <code>.pdf</code>, etc.
</li>
<li>For machine learning 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.
</li>
</ul>
<h2 id="how-to-install-the-notebook-using-pip-">How to Install the Notebook Using <code>pip</code></h2>
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.
What you do need to do is upgrade <code>pip</code> but before, that let&#39;s install and create a virtual environment:
<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>

Now let&#39;s create a virtual environment <code>jupyter</code> and activate it!
<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>

Let&#39;s upgrade <code>pip</code> now, but first, let&#39;s check the already installed <code>pip</code> version.
<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>

From the above output, you can see that we have <code>pip</code> version <code>20.2.1</code>.
Let&#39;s upgrade that:
<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>

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

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.
<h2 id="how-to-install-jupyter-notebook-using-anaconda">How to Install Jupyter Notebook Using Anaconda</h2>
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.
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.
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>.
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>.
If you need more information about installing packages in Python, you can go to <a href="https://packaging.python.org/installing/">this page</a>.
<h2 id="getting-started-with-jupyter-notebook">Getting Started With Jupyter Notebook</h2>
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!
<h3 id="launching-jupyter-notebook">Launching Jupyter Notebook</h3>
To launch your Jupyter notebook, simply type the below command!
<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>

Once you do this, the Jupyter notebook should open up the below tab for you inside your web browser:
<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>

Note that the Jupyter Notebook will open using the below URL:
<a href="http://localhost:8888/tree">http://localhost:8888/tree</a>
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.
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:
<a href="http://localhost:8889/?token=e41173caeda552cdcab1bcc775e2463ac510b8847f73604b">http://localhost:8889/?token=e41173caeda552cdcab1bcc775e2463ac510b8847f73604b</a>
Now, let&#39;s open a Python3 Notebook inside Jupyter by clicking the <code>New</code> tab and select <code>Python3</code>:
<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>

And finally, we have our very first Python3 Jupyter Notebook:
<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>
In the drop-down menu shown below, you have four options:
<ul>
<li>Code – In the code cell, you write the Python code.</li>
</ul>
<ul>
<li>Markdown – In this cell type, you can add headings, notes, documentation, etc.</li>
</ul>
<ul>
<li>Raw NBConvert – 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>
Let&#39;s look at the <code>markdown</code> example for adding headings and bullet points:
<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>
This is one of the great and cool features of a Jupyter Notebook.
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:
<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>
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:
<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>
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.
First, let&#39;s import <code>numpy</code>.
<pre><code class="lang-python">import numpy as np
</code></pre>
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>.
<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>
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.
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>.

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

(Tutorial) Installing Jupyter Notebook

Installing Jupyter Notebook

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

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.
<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>
Below, we have a dataset that contains the average brain and body weights of 62 mammals.
<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>To understand the relationship here, the most obvious first step is to make a scatter plot, like the one shown below:
<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>

Two mammals, the African and the Asian Elephants have both very large brain and body weights, leading to a positive skew on both axes.
<h2 id="linear-model">Linear Model</h2>
Now, if we were to apply a linear model, it would be a poor choice since a few extreme values have a large influence.
<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>

Applying a log transformation of both variables allows for a better fit.
<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>


So, although we began with a rough exploratory plot, it informed us about our data and led us to a meaningful result.
<h3 id="anscombe-s-plots">Anscombe&#39;s Plots</h3>
When we imagine a linear model, as presented on this anonymous plot, we imagine that we are describing data that looks something like this.
<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>

But this same model could be describing a very different set of data, such as a parabolic relationship, which calls for a different model.
<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>

Or data in which an extreme value has a large effect. which becomes clear when the outlier is removed.
<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>

And sometimes, the model may be describing a relationship where, in fact, there is none at all because some extreme values may be incorrect.
<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>

If we relied solely on the numerical output without plotting our data, we&#39;d have missed distinct and interesting underlying trends.
<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>

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.
<h2 id="interactive-example">Interactive Example</h2>
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.
Finally, you will visualize the ggplot and try to understand what ggplot does with the data.
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.
<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>
When we run the above code, it produces the following result:
<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>


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

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.

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.

(Tutorial) Convolutional Neural Networks with TensorFlow

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

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>.
<a id='initialization'></a>
<h2 id="variable">Variable</h2>
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 assignment operator (<code>=</code>, a single equals sign) and assign the desired value to it.
<pre><code class="lang-python">first_string_var = &quot;First String&quot; 
first_int_var = 1
total = 1 + 2 * 3
</code></pre>
Assigning an initial value to a variable is called initializing the variable. You just initialized the variable: <code>first_string_var</code> with a string value of First String and variable <code>first_int_var</code> with an integer or numeric value of 1. 
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.
Python has some rules that you must follow when creating a variable...
<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>
If you do not follow these rules, you will get an error. Try it for yourself:
<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>
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 LEGB rule. LEGB stands for Local -&gt; Enclosing -&gt; Global -&gt; Built-in.
Let&#39;s learn more about scopes...
<a id='local'></a>
<h2 id="local-scope">Local Scope</h2>
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:
<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>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.
<a id='enclosing'></a>
<h2 id="enclosing-scope">Enclosing Scope</h2>
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.
<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>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>. 
This is an enclosing scope. <code>Outer</code>&#39;s variables have a larger scope and can be accessed from the enclosed function <code>inner()</code>.
<a id='global'></a>
<h2 id="global-scope">Global Scope</h2>
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.
<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><a id='builtin'></a>
<h2 id="built-in-scope">Built-in Scope</h2>
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.
Keywords are simply special reserved words. They are kept for specific purposes and cannot be used for any other purpose in the program. 
These are the keywords in Python:
<img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1588956604/keywords_c8hxf4.png" align="left"/> 
<h2 id="legb-rule">LEGB Rule</h2>
LEGB (Local -&gt; Enclosing -&gt; Global -&gt; Built-in) is the logic followed by a Python interpreter when it is executing your program.
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.
<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"/>
So far, so good!
Next, let&#39;s revisit some examples from before to see if they can create problems when the use-case becomes slightly more complex.
<h3 id="scenario-1-global-scope">Scenario 1: Global Scope</h3>
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;
<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>Well...that did not go as wanted! Why?
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 global keyword comes in handy.
<a id='globalkeyword'></a>
<h2 id="global-keyword">Global Keyword</h2>
With global, 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.
<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>That worked! Let&#39;s move to the next scenario...
<h3 id="scenario-2-enclosing-scope">Scenario 2: Enclosing Scope</h3>
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>.
<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>It isn&#39;t always that simple, is it! For such purposes, we make use of nonlocal keyword within Python.
<a id='nonlocal'></a>
<h2 id="nonlocal-keyword">Nonlocal Keyword</h2>
This is another handy keyword that allows us to work more flexibly and tidily with variable scopes. The nonlocal 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.
<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>And there you have it!
<h2 id="conclusion">Conclusion</h2>
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.

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

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

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

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

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

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

(Tutorial) Docstrings in Python

Docstrings in Python

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

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

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

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



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





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

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

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

(Tutorial) Definitive Guide: Variables in R

Definitive Guide: Variables in R

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

tutorial

on

python

print

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


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

TypeError Traceback (most recent call last)

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


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

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

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

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

(Tutorial) Python Print() Function

Python Print() Function

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

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. 

(Tutorial) Choosing Python or R for Data Analysis? An Infographic

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, their properties, transition MATRICES, and implement one yourself in PYTHON!

(Tutorial) Markov Chains in Python

Markov Chains in Python: Beginner Tutorial

<center><a target=“_blank” href="https://www.datacamp.com/learn/r-programming/"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1583330891/r_2_t6hgbx.png" /></a>
</center> 
Data mining or machine learning techniques can oftentimes be utilized at
early stages of biomedical research to analyze large datasets, for
example, to aid the identification of candidate genes or predictive
disease biomarkers in high-throughput sequencing datasets. However, data
from clinical trials usually include “survival data” that require a
quite different approach to analysis.
In this type of analysis, the time to a specific event, such as death or
disease recurrence, is of interest and two (or more) groups of patients
are compared with respect to this time. Three core concepts can be used
to derive meaningful results from such a dataset and the aim of this
tutorial is to introduce the statistical concepts, their interpretation,
as well as a real-world application of these methods along with their
implementation in R:
In this post, you&#39;ll tackle the following topics:
<nav>
<ul>
<li><a href="#second">The Statistics behind Survival Analysis</a><ul>
<li><a href="#third">Kaplan-Meier Method and Log-Rank Test</a></li>
<li><a href="#fourth">Cox Proportional Hazards Models</a></li>
</ul>
</li>
<li><a href="#fifth">Implementation of a Survival Analysis in R</a>
</nav>
<div id="scoped-content"><style type="text/css">:target:before { content:""; display:block; height:150px; margin:-150px 0 0; } h3 {font-weight:normal; margin-top:.5em} h4 { font-weight:lighter }
</style>

</li>
</ul>
In this tutorial, you are also going to use the <code>survival</code> and
<code>survminer</code> packages in R and the <code>ovarian</code> dataset (Edmunson J.H. et al., 1979) that comes with the <code>survival</code> package. You&#39;ll read more about this dataset later on in this tutorial!
Tip: check out <a href="https://www.rstudio.com/wp-content/uploads/2015/01/survminer-1.png">this <code>survminer</code> cheat sheet</a>
After this tutorial, you will be able to take advantage of these
data to answer questions such as the following: do patients benefit from
therapy regimen A as opposed to regimen B? Do patients’ age and fitness
significantly influence the outcome? Is residual disease a prognostic
biomarker in terms of survival?
<a id="second"></a>
<h2 id="survival-analysis-the-statistics">Survival Analysis: The Statistics</h2>
Before you go into detail with the statistics, you might want to learn
about some useful terminology:
The term &quot;censoring&quot; refers to incomplete data. Although different types
exist, you might want to restrict yourselves to right-censored data at
this point since this is the most common type of censoring in survival
datasets. 
For some patients, you might know that he or she was
followed-up on for a certain time without an “event” occurring, but you
might not know whether the patient ultimately survived or not. This can
be the case if the patient was either lost to follow-up or a subject
withdrew from the study. The data on this particular patient is going to
be “censored” after the last time point at which you know for sure that
your patient did not experience the “event” you are looking for. An
event is the pre-specified endpoint of your study, for instance death or
disease recurrence. Also, all patients who do not experience the “event”
until the study ends will be censored at that last time point.
Basically, these are the three reason why data could be censored.
Thus, the number of censored observations is always <code>n &gt;= 0</code>. All these
examples are instances of “right-censoring” and one can further classify
into either fixed or random type I censoring and type II censoring, but
these classifications are relevant mostly from the standpoint of
study-design and will not concern you in this introductory tutorial.
Something you should keep in mind is that all types of censoring are
cases of non-information and censoring is never caused by the “event”
that defines the endpoint of your study. That also implies that none of
the censored patients in the <code>ovarian</code> dataset were censored because the
respective patient died.
<a id="third"></a>
<h3 id="kaplan-meier-method-and-log-rank-test">Kaplan-Meier Method and Log Rank Test</h3>
Now, how does a survival function that describes patient survival over
time look like? 
The Kaplan-Meier estimator, independently described by
Edward Kaplan and Paul Meier and conjointly published in 1958 in the
Journal of the American Statistical Association, is a non-parametric
statistic that allows us to estimate the survival function.
Remember that a non-parametric statistic is not based on the
assumption of an underlying probability distribution, which makes sense
since survival data has a skewed distribution.
This statistic gives the probability that an individual patient will
survive past a particular time <code>t</code>. At <code>t = 0</code>, the Kaplan-Meier
estimator is <code>1</code> and with <code>t</code> going to infinity, the estimator goes to
<code>0</code>. In theory, with an infinitely large dataset and t measured to the
second, the corresponding function of <code>t</code> versus survival probability is
smooth. Later, you will see how it looks like in practice.
It is further based on the assumption that the probability of surviving
past a certain time point <code>t</code> is equal to the product of the observed
survival rates until time point <code>t</code>. More precisely,
<code>S(t) #the survival probability at time t</code> is given by
<code>S(t) = p.1 * p.2 * … * p.t</code> with <code>p.1</code> being the proportion of all
patients surviving past the first time point, <code>p.2</code> being the proportion
of patients surviving past the second time point, and so forth until
time point <code>t</code> is reached. 
It is important to notice that, starting with
<code>p.2</code> and up to <code>p.t</code>, you take only those patients into account who
survived past the previous time point when calculating the proportions
for every next time point; thus, <code>p.2</code>, <code>p.3</code>, <code>…</code>, <code>p.t</code> are
proportions that are conditional on the previous proportions.
In practice, you want to organize the survival times in order of
increasing duration first. This includes the censored values. You then
want to calculate the proportions as described above and sum them up to
derive <code>S(t)</code>. Censored patients are omitted after the time point of
censoring, so they do not influence the proportion of surviving
patients. For detailed information on the method, refer to (Swinscow and
Campbell, 2002). 
As a last note, you can use the log-rank test to
compare survival curves of two groups. The log-rank test is a
statistical hypothesis test that tests the null hypothesis that survival
curves of two populations do not differ. A certain probability
distribution, namely a chi-squared distribution, can be used to derive a
p-value. Briefly, p-values are used in statistical hypothesis testing to
quantify statistical significance. A result with <code>p &lt; 0.05</code> is usually
considered significant. In our case, <code>p &lt; 0.05</code> would indicate that the
two treatment groups are significantly different in terms of survival.
<a id="fourth"></a>
<h3 id="cox-proportional-hazards-models">Cox Proportional Hazards Models</h3>
Another useful function in the context of survival analyses is the
hazard function <code>h(t)</code>. It describes the probability of an event or its
hazard <code>h</code> (again, survival in this case) if the subject survived up to
that particular time point <code>t</code>. It is a bit more difficult to illustrate
than the Kaplan-Meier estimator because it measures the instantaneous
risk of death. Nevertheless, you need the hazard function to consider
covariates when you compare survival of patient groups. Covariates, also
called explanatory or independent variables in regression analysis, are
variables that are possibly predictive of an outcome or that you might
want to adjust for to account for interactions between variables.
Whereas the log-rank test compares two Kaplan-Meier survival curves,
which might be derived from splitting a patient population into
treatment subgroups, Cox proportional hazards models are derived from
the underlying baseline hazard functions of the patient populations in
question and an arbitrary number of dichotomized covariates. Again, it
does not assume an underlying probability distribution but it assumes
that the hazards of the patient groups you compare are constant over
time. That is why it is called “proportional hazards model”. Later, you
will see an example that illustrates these theoretical considerations.
Now, let’s try to analyze the <code>ovarian</code> dataset!
<a id="fifth"></a>
<h2 id="implementation-of-a-survival-analysis-in-r">Implementation of a Survival Analysis in R</h2>
With these concepts at hand, you can now start to analyze an actual
dataset and try to answer some of the questions above. Let’s start by
loading the two packages required for the analyses and the <code>dplyr</code>
package that comes with some useful functions for managing data frames.
<pre><code># Load required packages
library(survival)
library(survminer)
library(dplyr)
</code></pre>Tip: don&#39;t forget to use <code>install.packages()</code> to install any
packages that might still be missing in your workspace!
The next step is to load the dataset and examine its structure. As you read in the beginning of this tutorial, you&#39;ll work with the <code>ovarian</code> data set. This dataset comprises a cohort of ovarian cancer patients and respective clinical information, including the time patients were tracked until they either died or were lost to follow-up (<code>futime</code>), whether patients were censored or not (<code>fustat</code>), patient age, treatment group assignment, presence of residual disease and performance status. 
As you can already see, some of the variables’ names are a little cryptic, you might also want to consult the help page.
<pre><code># Import the ovarian cancer dataset and have a look at it
data(ovarian)
glimpse(ovarian)
## Observations: 26
## Variables: 6
## $ futime &lt;dbl&gt; 59, 115, 156, 421, 431, 448, 464, 475, 477, 563, 638,...
## $ fustat &lt;dbl&gt; 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0,...
## $ age &lt;dbl&gt; 72.3315, 74.4932, 66.4658, 53.3644, 50.3397, 56.4301,...
## $ resid.ds &lt;dbl&gt; 2, 2, 2, 2, 2, 1, 2, 2, 2, 1, 1, 1, 2, 2, 1, 1, 2, 1,...
## $ rx &lt;dbl&gt; 1, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 2, 2, 2, 1, 1, 1, 1,...
## $ ecog.ps &lt;dbl&gt; 1, 1, 2, 1, 1, 2, 2, 2, 1, 2, 2, 1, 2, 1, 1, 2, 2, 1,...
help(ovarian)
</code></pre>The <code>futime</code> column holds the survival times. This is the response
variable. <code>fustat</code>, on the other hand, tells you if an individual
patients’ survival time is censored. Apparently, the 26 patients in this
study received either one of two therapy regimens (<code>rx</code>) and the
attending physician assessed the regression of tumors (<code>resid.ds</code>) and
patients’ performance (according to the standardized ECOG criteria;
<code>ecog.ps</code>) at some point.
Furthermore, you get information on patients’ age and if you want to
include this as a predictive variable eventually, you have to
dichotomize continuous to binary values. But what cutoff should you
choose for that? Let us look at the overall distribution of age values:
<pre><code># Dichotomize age and change data labels
ovarian$rx &lt;- factor(ovarian$rx, 
 levels = c(&quot;1&quot;, &quot;2&quot;), 
 labels = c(&quot;A&quot;, &quot;B&quot;))
ovarian$resid.ds &lt;- factor(ovarian$resid.ds, 
 levels = c(&quot;1&quot;, &quot;2&quot;), 
 labels = c(&quot;no&quot;, &quot;yes&quot;))
ovarian$ecog.ps &lt;- factor(ovarian$ecog.ps, 
 levels = c(&quot;1&quot;, &quot;2&quot;), 
 labels = c(&quot;good&quot;, &quot;bad&quot;))

# Data seems to be bimodal
hist(ovarian$age) 
</code></pre><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1522843408/survival_lhlkdg.png"/>
<pre><code>ovarian &lt;- ovarian %&gt;% mutate(age_group = ifelse(age &gt;=50, &quot;old&quot;, &quot;young&quot;))
ovarian$age_group &lt;- factor(ovarian$age_group)
</code></pre>The obviously bi-modal distribution suggests a cutoff of 50 years. You
can use the <code>mutate</code> function to add an additional <code>age_group</code> column to
the data frame that will come in handy later on. Also, you should
convert the future covariates into factors.
Now, you are prepared to create a survival object. That is basically a
compiled version of the <code>futime</code> and <code>fustat</code> columns that can be
interpreted by the <code>survfit</code> function. A <code>+</code> behind survival times
indicates censored data points.
<pre><code># Fit survival data using the Kaplan-Meier method
surv_object &lt;- Surv(time = ovarian$futime, event = ovarian$fustat)
surv_object 
## [1] 59 115 156 421+ 431 448+ 464 475 477+ 563 638 
## [12] 744+ 769+ 770+ 803+ 855+ 1040+ 1106+ 1129+ 1206+ 1227+ 268 
## [23] 329 353 365 377+
</code></pre>The next step is to fit the Kaplan-Meier curves. You can easily do that
by passing the <code>surv_object</code> to the <code>survfit</code> function. You can also
stratify the curve depending on the treatment regimen <code>rx</code> that patients
were assigned to. A <code>summary()</code> of the resulting <code>fit1</code> object shows,
among other things, survival times, the proportion of surviving patients
at every time point, namely your <code>p.1</code>, <code>p.2</code>, <code>...</code> from above, and
treatment groups.
<pre><code>fit1 &lt;- survfit(surv_object ~ rx, data = ovarian)
summary(fit1)
## Call: survfit(formula = surv_object ~ rx, data = ovarian)
## 
## rx=A 
## time n.risk n.event survival std.err lower 95% CI upper 95% CI
## 59 13 1 0.923 0.0739 0.789 1.000
## 115 12 1 0.846 0.1001 0.671 1.000
## 156 11 1 0.769 0.1169 0.571 1.000
## 268 10 1 0.692 0.1280 0.482 0.995
## 329 9 1 0.615 0.1349 0.400 0.946
## 431 8 1 0.538 0.1383 0.326 0.891
## 638 5 1 0.431 0.1467 0.221 0.840
## 
## rx=B 
## time n.risk n.event survival std.err lower 95% CI upper 95% CI
## 353 13 1 0.923 0.0739 0.789 1.000
## 365 12 1 0.846 0.1001 0.671 1.000
## 464 9 1 0.752 0.1256 0.542 1.000
## 475 8 1 0.658 0.1407 0.433 1.000
## 563 7 1 0.564 0.1488 0.336 0.946
</code></pre>You can examine the corresponding survival curve by passing the survival
object to the <code>ggsurvplot</code> function. The <code>pval = TRUE</code> argument is very
useful, because it plots the p-value of a log rank test as well!
<pre><code>ggsurvplot(fit1, data = ovarian, pval = TRUE)
</code></pre><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1522843408/survival1_g30vej.png"/>
By convention, vertical lines indicate censored data, their
corresponding x values the time at which censoring occurred.
The log-rank p-value of 0.3 indicates a non-significant result if you
consider <code>p &lt; 0.05</code> to indicate statistical significance. In this study,
none of the treatments examined were significantly superior, although
patients receiving treatment B are doing better in the first month of
follow-up. What about the other variables?
<pre><code># Examine prdictive value of residual disease status
fit2 &lt;- survfit(surv_object ~ resid.ds, data = ovarian)
ggsurvplot(fit2, data = ovarian, pval = TRUE)
</code></pre><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1522843408/survival2_komvqh.png"/>
The Kaplan-Meier plots stratified according to residual disease status
look a bit different: The curves diverge early and the log-rank test is
almost significant. You might want to argue that a follow-up study with
an increased sample size could validate these results, that is, that
patients with positive residual disease status have a significantly
worse prognosis compared to patients without residual disease.
But is there a more systematic way to look at the different covariates?
As you might remember from one of the previous passages, Cox
proportional hazards models allow you to include covariates. You can
build Cox proportional hazards models using the <code>coxph</code> function and
visualize them using the <code>ggforest</code>. These type of plot is called a
forest plot. It shows so-called hazard ratios (HR) which are derived
from the model for all covariates that we included in the formula in
<code>coxph</code>. Briefly, an HR &gt; 1 indicates an increased risk of death
(according to the definition of <code>h(t)</code>) if a specific condition is met
by a patient. An HR &lt; 1, on the other hand, indicates a decreased
risk. Let&#39;s look at the output of the model:
<pre><code># Fit a Cox proportional hazards model
fit.coxph &lt;- coxph(surv_object ~ rx + resid.ds + age_group + ecog.ps, 
 data = ovarian)
ggforest(fit.coxph, data = ovarian)
</code></pre><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1522843408/survival3_t8aocz.png"/>
Every HR represents a relative risk of death that compares one instance
of a binary feature to the other instance. For example, a hazard ratio
of 0.25 for treatment groups tells you that patients who received
treatment B have a reduced risk of dying compared to patients who
received treatment A (which served as a reference to calculate the
hazard ratio). As shown by the forest plot, the respective 95%
confidence interval is 0.071 - 0.89 and this result is significant.
Using this model, you can see that the treatment group, residual disease
status, and age group variables significantly influence the patients&#39;
risk of death in this study. This is quite different from what you saw
with the Kaplan-Meier estimator and the log-rank test. Whereas the
former estimates the survival probability, the latter calculates the
risk of death and respective hazard ratios. Your analysis shows that the
results that these methods yield can differ in terms of significance.
<h2 id="conclusion">Conclusion</h2>
The examples above show how easy it is to implement the statistical
concepts of survival analysis in R. In this introduction, you have
learned how to build respective models, how to visualize them, and also
some of the statistical background information that helps to understand
the results of your analyses. Hopefully, you can now start to use these
techniques to analyze your own datasets. Thanks for reading this
tutorial!

https://www.datacamp.com/community/tutorials/survival-analysis-R

In this tutorial, you'll learn about the statistical concepts behind survival analysis and you'll implement a real-world application of these methods in R.

Learn about the STATISTICAL concepts behind SURVIVAL ANALYSIS and implement a real-world application of these METHODS in R.

(Tutorial) Survival ANALYSIS in R For BEGINNERS

Survival Analysis in R For Beginners

<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/v1583330891/python_3_qgciu1.png" /></a>
</center>
Classification techniques are an essential part of machine learning and data mining applications. Approximately 70% of problems in Data Science are classification problems. There are lots of classification problems that are available, but the logistics regression is common and is a useful regression method for solving the binary classification problem. Another category of classification is Multinomial classification, which handles the issues where multiple classes are present in the target variable. For example, IRIS dataset a very famous example of multi-class classification. Other examples are classifying article/blog/document category.
Logistic Regression can be used for various classification problems such as spam detection. Diabetes prediction, if a given customer will purchase a particular product or will they churn another competitor, whether the user will click on a given advertisement link or not, and many more examples are in the bucket.
Logistic Regression is one of the most simple and commonly used Machine Learning algorithms for two-class classification. It is easy to implement and can be used as the baseline for any binary classification problem. Its basic fundamental concepts are also constructive in deep learning. Logistic regression describes and estimates the relationship between one dependent binary variable and independent variables.
In this tutorial, you will learn the following things in Logistic Regression:
<ul>
<li>Introduction to Logistic Regression</li>
<li>Linear Regression Vs. Logistic Regression</li>
<li>Maximum Likelihood Estimation Vs. Ordinary Least Square Method</li>
<li>How do Logistic Regression works?</li>
<li>Model building in Scikit-learn</li>
<li>Model Evaluation using Confusion Matrix.</li>
<li>Advantages and Disadvantages of Logistic Regression</li>
</ul>
<h3 id="logistic-regression">Logistic Regression</h3>
Logistic regression is a statistical method for predicting binary classes. The outcome or target variable is dichotomous in nature. Dichotomous means there are only two possible classes. For example, it can be used for cancer detection problems. It computes the probability of an event occurrence.
It is a special case of linear regression where the target variable is categorical in nature. It uses a log of odds as the dependent variable. Logistic Regression predicts the probability of occurrence of a binary event utilizing a logit function.
Linear Regression Equation:
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281880/image1_ga8gze.png" />
Where, y is dependent variable and x1, x2 ... and Xn are explanatory variables.
Sigmoid Function:
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281880/image2_kwxquj.png" />
Apply Sigmoid function on linear regression:
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281880/image3_qldafx.png" />
Properties of Logistic Regression:
<ul>
<li>The dependent variable in logistic regression follows Bernoulli Distribution.</li>
<li>Estimation is done through maximum likelihood.</li>
<li>No R Square, Model fitness is calculated through Concordance, KS-Statistics.</li>
</ul>
<h3 id="linear-regression-vs-logistic-regression">Linear Regression Vs. Logistic Regression</h3>
Linear regression gives you a continuous output, but logistic regression provides a constant output. An example of the continuous output is house price and stock price. Example&#39;s of the discrete output is predicting whether a patient has cancer or not, predicting whether the customer will churn. Linear regression is estimated using Ordinary Least Squares (OLS) while logistic regression is estimated using Maximum Likelihood Estimation (MLE) approach.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281070/linear_vs_logistic_regression_edxw03.png" />
<h3 id="maximum-likelihood-estimation-vs-least-square-method">Maximum Likelihood Estimation Vs. Least Square Method</h3>
The MLE is a &quot;likelihood&quot; maximization method, while OLS is a distance-minimizing approximation method. Maximizing the likelihood function determines the parameters that are most likely to produce the observed data. From a statistical point of view, MLE sets the mean and variance as parameters in determining the specific parametric values for a given model. This set of parameters can be used for predicting the data needed in a normal distribution.
Ordinary Least squares estimates are computed by fitting a regression line on given data points that has the minimum sum of the squared deviations (least square error). Both are used to estimate the parameters of a linear regression model. MLE assumes a joint probability mass function, while OLS doesn&#39;t require any stochastic assumptions for minimizing distance.
<h3 id="sigmoid-function">Sigmoid Function</h3>
The sigmoid function, also called logistic function gives an ‘S’ shaped curve that can take any real-valued number and map it into a value between 0 and 1. If the curve goes to positive infinity, y predicted will become 1, and if the curve goes to negative infinity, y predicted will become 0. If the output of the sigmoid function is more than 0.5, we can classify the outcome as 1 or YES, and if it is less than 0.5, we can classify it as 0 or NO. The outputcannotFor example: If the output is 0.75, we can say in terms of probability as: There is a 75 percent chance that patient will suffer from cancer.
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281880/image4_gw5mmv.png" />
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281070/sigmoid2_lv4c7i.png" />
<h3 id="types-of-logistic-regression">Types of Logistic Regression</h3>
Types of Logistic Regression:
<ul>
<li>Binary Logistic Regression: The target variable has only two possible outcomes such as Spam or Not Spam, Cancer or No Cancer.</li>
<li>Multinomial Logistic Regression: The target variable has three or more nominal categories such as predicting the type of Wine.</li>
<li>Ordinal Logistic Regression: the target variable has three or more ordinal categories such as restaurant or product rating from 1 to 5.</li>
</ul>
<h3 id="model-building-in-scikit-learn">Model building in Scikit-learn</h3>
Let&#39;s build the diabetes prediction model.
Here, you are going to predict diabetes using Logistic Regression Classifier.
Let&#39;s first load the required Pima Indian Diabetes dataset using the pandas&#39; read CSV function. You can download data from the following link: <a href="https://www.kaggle.com/uciml/pima-indians-diabetes-database">https://www.kaggle.com/uciml/pima-indians-diabetes-database</a>
<h4 id="loading-data">Loading Data</h4>
<pre><code class="lang-python">#import pandas
import pandas as pd
col_names = [&#39;pregnant&#39;, &#39;glucose&#39;, &#39;bp&#39;, &#39;skin&#39;, &#39;insulin&#39;, &#39;bmi&#39;, &#39;pedigree&#39;, &#39;age&#39;, &#39;label&#39;]
# load dataset
pima = pd.read_csv(&quot;pima-indians-diabetes.csv&quot;, header=None, names=col_names)
</code></pre>
<pre><code class="lang-python">pima.head()
</code></pre>
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281070/Screen_Shot_2018-08-14_at_5.06.08_PM_ykb1jt.png" />
<h4 id="selecting-feature">Selecting Feature</h4>
Here, you need to divide the given columns into two types of variables dependent(or target variable) and independent variable(or feature variables).
<pre><code class="lang-python">#split dataset in features and target variable
feature_cols = [&#39;pregnant&#39;, &#39;insulin&#39;, &#39;bmi&#39;, &#39;age&#39;,&#39;glucose&#39;,&#39;bp&#39;,&#39;pedigree&#39;]
X = pima[feature_cols] # Features
y = pima.label # Target variable
</code></pre>
<h4 id="splitting-data">Splitting Data</h4>
To understand model performance, dividing the dataset into a training set and a test set is a good strategy.
Let&#39;s split dataset by using function train_test_split(). You need to pass 3 parameters features, target, and test_set size. Additionally, you can use random_state to select records randomly.
<pre><code class="lang-python"># split X and y into training and testing sets
from sklearn.cross_validation import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.25,random_state=0)
</code></pre>
<pre><code>/home/admin/.local/lib/python3.5/site-packages/sklearn/cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also, note that the interface of the new CV iterators is different from that of this module. This module will be removed in 0.20.
 &quot;This module will be removed in 0.20.&quot;, DeprecationWarning)
</code></pre>Here, the Dataset is broken into two parts in a ratio of 75:25. It means 75% data will be used for model training and 25% for model testing.
<h4 id="model-development-and-prediction">Model Development and Prediction</h4>
First, import the Logistic Regression module and create a Logistic Regression classifier object using LogisticRegression() function.
Then, fit your model on the train set using fit() and perform prediction on the test set using predict().
<pre><code class="lang-python"># import the class
from sklearn.linear_model import LogisticRegression

# instantiate the model (using the default parameters)
logreg = LogisticRegression()

# fit the model with data
logreg.fit(X_train,y_train)

#
y_pred=logreg.predict(X_test)
</code></pre>
<h3 id="model-evaluation-using-confusion-matrix">Model Evaluation using Confusion Matrix</h3>
A confusion matrix is a table that is used to evaluate the performance of a classification model. You can also visualize the performance of an algorithm. The fundamental of a confusion matrix is the number of correct and incorrect predictions are summed up class-wise.
<pre><code class="lang-python"># import the metrics class
from sklearn import metrics
cnf_matrix = metrics.confusion_matrix(y_test, y_pred)
cnf_matrix
</code></pre>
<pre><code>array([[119, 11],
 [ 26, 36]])
</code></pre>Here, you can see the confusion matrix in the form of the array object. The dimension of this matrix is 2*2 because this model is binary classification. You have two classes 0 and 1. Diagonal values represent accurate predictions, while non-diagonal elements are inaccurate predictions. In the output, 119 and 36 are actual predictions, and 26 and 11 are incorrect predictions. 
<h4 id="visualizing-confusion-matrix-using-heatmap">Visualizing Confusion Matrix using Heatmap</h4>
Let&#39;s visualize the results of the model in the form of a confusion matrix using matplotlib and seaborn.
Here, you will visualize the confusion matrix using Heatmap.
<pre><code class="lang-python"># import required modules
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
</code></pre>
<pre><code class="lang-python">class_names=[0,1] # name of classes
fig, ax = plt.subplots()
tick_marks = np.arange(len(class_names))
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names)
# create heatmap
sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap=&quot;YlGnBu&quot; ,fmt=&#39;g&#39;)
ax.xaxis.set_label_position(&quot;top&quot;)
plt.tight_layout()
plt.title(&#39;Confusion matrix&#39;, y=1.1)
plt.ylabel(&#39;Actual label&#39;)
plt.xlabel(&#39;Predicted label&#39;)
</code></pre>
<pre><code>Text(0.5,257.44,&#39;Predicted label&#39;)
</code></pre><center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281070/output_46_1_y8ftmf.png" />
<h4 id="confusion-matrix-evaluation-metrics">Confusion Matrix Evaluation Metrics</h4>
Let&#39;s evaluate the model using model evaluation metrics such as accuracy, precision, and recall.
<pre><code class="lang-python">print(&quot;Accuracy:&quot;,metrics.accuracy_score(y_test, y_pred))
print(&quot;Precision:&quot;,metrics.precision_score(y_test, y_pred))
print(&quot;Recall:&quot;,metrics.recall_score(y_test, y_pred))
</code></pre>
<pre><code>Accuracy: 0.8072916666666666
Precision: 0.7659574468085106
Recall: 0.5806451612903226
</code></pre>Well, you got a classification rate of 80%, considered as good accuracy.
Precision: Precision is about being precise, i.e., how accurate your model is. In other words, you can say, when a model makes a prediction, how often it is correct. In your prediction case, when your Logistic Regression model predicted patients are going to suffer from diabetes, that patients have 76% of the time.
Recall: If there are patients who have diabetes in the test set and your Logistic Regression model can identify it 58% of the time.
<h4 id="roc-curve">ROC Curve</h4>
Receiver Operating Characteristic(ROC) curve is a plot of the true positive rate against the false positive rate. It shows the tradeoff between sensitivity and specificity.
<pre><code class="lang-python">y_pred_proba = logreg.predict_proba(X_test)[::,1]
fpr, tpr, _ = metrics.roc_curve(y_test, y_pred_proba)
auc = metrics.roc_auc_score(y_test, y_pred_proba)
plt.plot(fpr,tpr,label=&quot;data 1, auc=&quot;+str(auc))
plt.legend(loc=4)
plt.show()
</code></pre>
<center><img src="http://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1534281070/output_53_0_qqcjsm.png" />
AUC score for the case is 0.86. AUC score 1 represents perfect classifier, and 0.5 represents a worthless classifier.
<h3 id="advantages">Advantages</h3>
Because of its efficient and straightforward nature, doesn&#39;t require high computation power, easy to implement, easily interpretable, used widely by data analyst and scientist. Also, it doesn&#39;t require scaling of features. Logistic regression provides a probability score for observations.
<h3 id="disadvantages">Disadvantages</h3>
Logistic regression is not able to handle a large number of categorical features/variables. It is vulnerable to overfitting. Also, can&#39;t solve the non-linear problem with the logistic regression that is why it requires a transformation of non-linear features. Logistic regression will not perform well with independent variables that are not correlated to the target variable and are very similar or correlated to each other.
<h3 id="conclusion">Conclusion</h3>
In this tutorial, you covered a lot of details about Logistic Regression. You have learned what the logistic regression is, how to build respective models, how to visualize results and some of the theoretical background information. Also, you covered some basic concepts such as the sigmoid function, maximum likelihood, confusion matrix, ROC curve.
Hopefully, you can now utilize the Logistic Regression technique to analyze your own datasets. Thanks for reading this tutorial!
If you would like to learn more about Logistic Regression, take DataCamp&#39;s <a href="https://www.datacamp.com/courses/foundations-of-predictive-analytics-in-python-part-1">Foundations of Predictive Analytics in Python (Part 1)</a> course.

https://www.datacamp.com/community/tutorials/understanding-logistic-regression-python

Learn about Logistic Regression, its basic properties, and build a machine learning model on a real-world application in Python.

Learn about LOGISTIC REGRESSION, its basic properties, and build a MACHINE LEARNING model on a real-world application in PYTHON.

community

datacamp

Tutorials