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

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

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

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

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

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

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

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

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

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

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

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

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


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

(Tutorial) Installing Jupyter Notebook

Installing Jupyter Notebook

<p>SQL Server is a relational database management system. One of the key principles of the relational database is that data is stored across multiple tables.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/c_scale,f_auto,q_auto:best,w_564/v1603485855/join1_nitybm.png" /></center>

<p>We will need to be able to join tables together in order to extract the data we need. We use <code>primary</code> and <code>foreign</code> keys to join tables.</p>
<h2 id="primary-key">Primary Key</h2>
<p>A primary key is a column that is used to uniquely identify each row in a table. This uniqueness can be achieved by using a sequential integer as an identity column. Or sometimes, existing columns naturally contain unique values, and they can be used.</p>
<p>In the below example, we can see the first few rows from the <code>artist</code> table. It has two columns, <code>artist_id</code>, and <code>name</code>. The <code>artist_id</code> column acts as a primary key for this table, it is an integer column, and each value is different.</p>
<pre><code>+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+
</code></pre><p>Now let&#39;s look at the <code>album</code> table. Can you spot the primary key? Yes, it&#39;s the <code>album_id</code> column. It&#39;s common for the primary key to be named &quot;table-name underscore id&quot;. But, you&#39;ll have noticed there is also an <code>artist_id</code> column. That also consists of integers and has the same name as the <code>artist_id</code> column in the artist table. What does this mean?</p>
<pre><code>+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+
</code></pre><h2 id="foreign-keys">Foreign Keys</h2>
<p>Well, from the previous output, it is clear that the <code>artist_id</code> in the artist table acts as a <code>Foreign_key</code> to the album table. The <code>FOREIGN KEY</code> constraint is used to prevent actions that would destroy links between tables.</p>
<ul>
<li><code>artist</code> table</li>
</ul>
<pre><code>+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+
</code></pre><ul>
<li><code>album</code> table</li>
</ul>
<pre><code>+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+
</code></pre><p>This means that when the <code>artist_id</code> in the album table matches the <code>artist_id</code> in the artist table, those rows can be linked as a <code>JOIN</code>.</p>
<h2 id="joining-album-and-artist">Joining Album and Artist</h2>
<p>Rows 1 and 4 of the artist table have an <code>artist_id</code> of 1. The <code>artist_id</code> 1 in the artist table is AC/DC. So, when we join the two tables together, we return the album details from the album table, and the corresponding artist details from the artist table - joined using the <code>artist_id</code> field, which is common to both tables.</p>
<p>This is known as an <code>inner</code> join.</p>
<pre><code class="lang-SQL">SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist ON artist.artist_id = album.artist_id
WHERE album.artist_id = 1;
</code></pre>
<pre><code>+----------+-------------------------+-----------+-------------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
+----------+-------------------------+-----------+-------------|
</code></pre><p>We joined the album and artist tables by matching the <code>artist_id</code> from the artist table to the <code>artist_id</code> in the album table.</p>
<p>When selecting columns with the same name from different tables, you must fully qualify the column name. Otherwise, SQL Server will not know which table to <code>SELECT</code> the column from.</p>
<p>To fully qualify a column, you have to prefix it with the relevant table name, followed by a period.</p>
<h3 id="inner-join-syntax">Inner Join Syntax</h3>
<p>Here&#39;s a generic example to remind you of the syntax. When we select the relevant columns from the main table, <code>table_A</code> in this case, then select any additional column we want to join to, which in this case is <code>table_B</code>. Then we specify the join using the keywords <code>INNER JOIN</code> and <code>ON</code>, providing the necessary key columns from both the tables.</p>
<pre><code class="lang-sql">SELECT
    table_A.columnX,
    table_A.columnY,
    table_B.columnZ,
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key;
</code></pre>
<h2 id="not-using-a-where-clause">Not Using a <code>WHERE</code> Clause</h2>
<p>In this example, we don&#39;t specify a <code>WHERE</code> clause, so we return ALL combinations of ALL matches between the artist and album tables, again, based on the <code>artist_id</code> column, which is common to both.</p>
<pre><code class="lang-SQL">SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist on artist.artist_id = album.artist_id;
</code></pre>
<pre><code>+----------+---------------------------------------+-----------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
| 2        | Balls To The Wall       | 2         | Accept      |
| 3        | Restless and Wild       | 2         | Accept      |
+----------+---------------------------------------+-----------+
</code></pre><h2 id="multiple-inner-join">Multiple Inner Join</h2>
<p>You can also join more than two tables using <code>INNER JOINS</code>. You simply provide an additional <code>INNER JOIN</code> for each combination of tables. In our code below, we join tables A and B, and also B and C.</p>
<pre><code class="lang-SQL">SELECT
  table_A.columnX,
  table_A.columnY,
  table_B.columnZ table_C columnW
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key
INNER JOIN table_C ON table_C.foreign_key = table_B.primary_key;
</code></pre>
<p>To learn more about joining tables, please see this video from our course <a href="https://campus.datacamp.com/courses/introduction-to-sql-server/joining-tables?ex=1">Introduction to SQL Server</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/DRDFtejKZs8" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

<p>This content is taken from DataCamp’s <a href="https://www.datacamp.com/courses/introduction-to-sql-server">Introduction to SQL Server</a> course by John MacKintosh.</p>


https://www.datacamp.com/community/tutorials/sql-joins

(Tutorial) Joins in SQL

Joins in SQL

<p>SQL or structured query language is the native language for interacting with databases and is designed for exactly this purpose. It is a language of databases. A database models real-life entities like professors and universities by storing them in tables. Each table contains data from a single entity type. This reduces redundancy by storing entities only once. For example, there only needs to be one row of data containing a certain company&#39;s details. Lastly, a database can be used to model the relationship between entities.</p>
<p>If you would like to know how to learn the basics of SQL or become an expert, check out these blog posts:</p>
<ul>
<li><a href="https://www.datacamp.com/community/blog/how-to-learn-sql">How to Learn SQL</a></li>
<li><a href="https://www.datacamp.com/community/blog/blog-how-to-become-a-sql-expert">How to Become a SQL Expert</a></li>
</ul>
<h2 id="querying-databases">Querying Databases</h2>
<p>While SQL can be used to create and modify databases, this tutorial&#39;s focus will be on querying databases. A query is a request for data from a database table (or combination of tables). Querying is an essential skill for a data scientist since the data you need for your analyses will often live in databases.</p>
<p>In SQL, you can select data from a table using a <code>SELECT</code> statement. For example, the following query selects the <code>name</code> column from the <code>people</code> table:</p>
<pre><code class="lang-sql">SELECT name
FROM people;
</code></pre>
<p>In this query, <code>SELECT</code> and <code>FROM</code> are called keywords. In SQL, keywords are not case-sensitive, which means you can write the same query as:</p>
<pre><code class="lang-sql">select name
from people;
</code></pre>
<p>That said, it&#39;s good practice to make SQL keywords uppercase to distinguish them from other parts of your query, like column and table names.</p>
<p>It&#39;s also good practice to include a semicolon at the end of your query. This tells SQL where the end of your query is!</p>
<h2 id="sql-order-of-execution">SQL Order of Execution</h2>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603483591/SQL_order_of_execution_1_xd76fb_feygfm.png" /></center>

<p>Note: Your query will always need a SELECT and a FROM statement (to identify which columns you want returned from which table)—the others are optional.</p>
<h2 id="example-of-select">Example of SELECT</h2>
<p>In the following example, you will SELECT the <code>title</code> column from the <code>films</code> table.</p>
<pre><code class="lang-sql">SELECT title
FROM films;
</code></pre>
<p>When we run the above code, it produces the following result:</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/c_scale,f_auto,q_auto:best/v1603483189/whatsql4_knglmg.png" /></center>

<p><a href="https://campus.datacamp.com/courses/introduction-to-sql/selecting-columns?ex=7">Try it for yourself</a>.</p>
<p>This content is taken from DataCamp’s <a href="https://learn.datacamp.com/courses/introduction-to-sql">Introduction to SQL</a> course by Nick Carchedi.</p>


https://www.datacamp.com/community/tutorials/what-is-sql

(Tutorial) What is SQL?

What is SQL?

<p>Plot character or <em>pch</em> is the standard argument to set the character that will be plotted in a number of R functions.</p>
<p>Explanatory text can be added to a plot in several different forms, including axis labels, titles, legends, or a text added to the plot itself. Base graphics functions in R typically create axis labels by default, although these can be overridden through the argument <code>xlab()</code> that allows us to provide our own x-axis label and <code>ylab()</code> that allows us to provide our own y-axis label.</p>
<p>Some base graphics functions also provide default titles, but again, these can be overridden has we see here:</p>
<pre><code class="lang-python">library(MASS)
par(mfrow = c(1, 2))
plot(density(geyser$waiting))
plot(density(geyser$waiting), main = &quot;Estimated density: \n Old Faithful waiting times&quot;)
</code></pre>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603481962/pch_2_kukmll.png" /></center>


<p>The plot on the left uses the default title returned by the density function, which tells us that the plot was generated by this function using its default options and also gives the R specification for the variable whose density we are plotting. In the right-hand plot, this default title has been overridden by specifying the optional argument main. Note that by including the return character, backslash n, we are creating a two-line title in this character string.</p>
<h2 id="-text-function"><code>text()</code> Function</h2>
<p>Like the lines and points functions, text is a low-level graphics function that allows us to add explanatory text to the existing plot. To do this, we must specify the values for x and y, the coordinates on the plot where the text should appear, and labels, a character vector that specifies the text to be added.</p>
<pre><code class="lang-python">text(x, y, adj)
</code></pre>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/c_scale,f_auto,q_auto:best,w_575/v1603481260/pch3_ubupgd.png" /></center>

<p>By default, the text added to the plot is centered at the specified x values, but the optional argument <code>adj</code> can be used to modify the alignment.</p>
<p>It is noted that the <code>adj</code> argument to the <code>text()</code> function determines the horizontal placement of the text, and it can take any value between 0 (left-justified text) and 1 (right-justified text). In fact, this argument can take values outside this range. That is, making this value negative causes the text to start to the right of the specified <code>x</code> position. Similarly, making <code>adj</code> greater than 1 causes the text to end to the left of the <code>x</code> position.</p>
<pre><code class="lang-python">library(MASS)
plot(UScereal$fibre)
text(5, 28, &quot;&lt;-- Outliers [left-justified text at (5, 28)]&quot;, adj = 0)
text(65, 23, &quot;[Right-justified text at (65, 23)]&quot;, adj = 1, col = &quot;red&quot;)
text(5, 28, &quot;[Centered text (default) at (31, 18)]&quot;, col = &quot;blue&quot;)
</code></pre>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best,w_575/v1603481260/pch5_decn8p.png" /></center>

<h3 id="fonts-orientations-and-other-text-features">Fonts, Orientations, and Other Text Features</h3>
<p>Below we see some of the ways the appearance of added text can be changed through optional arguments to the text function. By default, text is created horizontally across the page, but this can be changed with the <code>srt</code> argument, which specifies the angle of orientation with respect to the horizontal axis.</p>
<p>Next, the text in red angles upward as a result of specifying <code>srt</code> as the positive value 30 degrees, while the text in green angles downward by specifying <code>srt</code> equals -45.</p>
<p>We can also specify the color of the text with the <code>col</code> argument, and the red text shows that we can change the text size with the <code>cex</code> argument. By specifying <code>cex = 1.2</code>, we have specified the text to be 20% larger than normal.</p>
<p>The other text characteristic that has been modified in this example is the font, set by the <code>font</code> argument. The default value is <code>font = 1</code>, which specifies normal text, while <code>font = 2</code> specifies boldface, <code>font = 3</code> specifies italics, and <code>font = 4</code> specifies both boldface and italics.</p>
<pre><code class="lang-python">library(MASS)
plot(Boston$rad)

# &quot;Inner city&quot; with adjusted colour and rotation
text(350, 24, adj = 1, &quot;Inner city? --&gt;&quot;, srt = 30, font = 2, cex = 1.2, col = &quot;red&quot;)

# &quot;Suburbs&quot; with adjusted colour and rotation
text(100, 15, &quot;Suburbs? --&gt;&quot;, srt = -45, font = 3, col = &quot;green&quot;)

title(&quot;Text with varying orientations, fonts, sizes &amp; colors&quot;)
</code></pre>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603481012/pch_1_qfa8ff.png" /></center>

<h2 id="adjusting-text-position-size-and-font">Adjusting Text Position, Size, and Font</h2>
<p>In the following example, you will:</p>
<ul>
<li>Create a plot of <code>MPG.city</code> vs. <code>Horsepower</code> from the <code>Cars93</code> data frame, with data represented as open circles (default <code>pch</code>).</li>
<li>Construct the variable <code>index3</code> using the <code>which()</code> function that identifies the row numbers containing all 3-cylinder cars.</li>
<li>Use the <code>points()</code> function to overlay solid circles, <code>pch = 16</code>, on top of all points in the plot that represent 3-cylinder cars.</li>
<li>Use the <code>text()</code> function with the <code>Make</code> variable as before to add labels to the right of the 3-cylinder cars, but now use <code>adj = 0.2</code> to move the labels further to the right, use the <code>cex</code> argument to increase the label size by 20 percent, and use the <code>font</code> argument to make the labels bold italic.</li>
</ul>
<pre><code class="lang-python"># Plot MPG.city vs. Horsepower as open circles
plot(Cars93$Horsepower, Cars93$MPG.city)

# Create index3, pointing to 3-cylinder cars
index3 &lt;- which(Cars93$Cylinders == 3)

# Highlight 3-cylinder cars as solid circles
points(Cars93$Horsepower[index3],
       Cars93$MPG.city[index3],
       pch = 16)

# Add car names, offset from points, with larger bold text
text(Cars93$Horsepower[index3],
     Cars93$MPG.city[index3],
     Cars93$Make[index3],
     adj = -0.2, cex = 1.2, font = 4)
</code></pre>
<p>When we run the above code, it produces the following result:</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603481260/pch2_uumynj.png" /></center>

<p><a href="https://campus.datacamp.com/courses/data-visualization-in-r/adding-details-to-plots?ex=11">Try it for yourself</a>.</p>
<p>To learn more about adding text to plots, please see this video from our course <a href="https://campus.datacamp.com/courses/data-visualization-in-r/adding-details-to-plots?ex=9">Data Visualization in R</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/VY6X27P2uAQ" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

<p>This content is taken from DataCamp’s <a href="https://www.datacamp.com/courses/introduction-to-data-visualization-with-ggplot2">Data Visualization in R</a> course by Ronald Pearson.</p>


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

(Tutorial) PCH in R

PCH in R

<p>String formatting is also known as String interpolation. It is the process of inserting a custom string or variable in predefined text.</p>
<pre><code class="lang-python">custom_string = &quot;String formatting&quot;
print(f&quot;{custom_string} is a powerful technique&quot;)
</code></pre>
<pre><code>String formatting is a powerful technique
</code></pre><p>As a data scientist, you would use it for inserting a title in a graph, show a message or an error, or pass a statement to a function.</p>
<h2 id="methods-for-formatting">Methods for formatting</h2>
<ul>
<li>Positional formatting</li>
<li>Formatted string literals</li>
<li>Template method</li>
</ul>
<h3 id="string-format-method">String.Format Method</h3>
<p>We put placeholders defined by a pair of curly braces in a text. We call the string dot format method. Then, we pass the desired value into the method. The method replaces the placeholders using the values in the order of appearance replace by value:</p>
<pre><code>&#39;text{}&#39;.format(value)
</code></pre><h2 id="positional-formatting">Positional Formatting</h2>
<p>We define a string and insert two placeholders. We pass two strings to the method, which will be passed to get the following output:</p>
<pre><code class="lang-python">print(&quot;Machine learning provides {} the ability to learn {}&quot;.format(&quot;systems&quot;, &quot;automatically&quot;))
</code></pre>
<pre><code>Machine learning provides systems the ability to learn automatically
</code></pre><p>We can use variables for both the string and the values passed to the method. In the below example code, we define a string with placeholders and two other variables. We apply the format method to the string using the two defined variables. The method reads the string and replaces the placeholders with the given values.</p>
<pre><code class="lang-python">my_string = &quot;{} rely on {} datasets&quot;
method = &quot;Supervised algorithms&quot;
condition = &quot;labeled&quot;
</code></pre>
<pre><code class="lang-python">print(my_string.format(method, condition))
</code></pre>
<pre><code>Supervised algorithms rely on labeled datasets
</code></pre><h2 id="reordering-values">Reordering Values</h2>
<p>In the below example, you add index numbers into the placeholders to reorder values. This affects the order in which the method replaces the placeholders.</p>
<p>The method replaces them with the values in the given order.</p>
<pre><code class="lang-python">print(&quot;{} has a friend called {} and a sister called {}&quot;. format(&quot;Betty&quot;, &quot;Linda&quot;, &quot;Daisy&quot;))
</code></pre>
<pre><code>Betty has a friend called Linda and a sister called Daisy
</code></pre><p>If we add the index numbers, the replacement order changes accordingly.</p>
<pre><code class="lang-python">print(&quot;{2} has a friend called {0} and a sister called {1}&quot;. format(&quot;Betty&quot;, &quot;Linda&quot;, &quot;Daisy&quot;))
</code></pre>
<pre><code>Daisy has a friend called Betty and a sister called Linda
</code></pre><h2 id="name-placeholders">Name Placeholders</h2>
<p>We can also introduce keyword arguments that are called by their keyword name.</p>
<p>In the example code below, we inserted keywords in the placeholders. Then, we call these keywords in the format method. We then assign which variable will be passed for each of them, resulting in the following output.</p>
<pre><code class="lang-python">tool=&quot;Unsupervised algorithms&quot;
goal=&quot;patterns&quot;
print(&quot;{title} try to find {aim} in the dataset&quot;.format(title=tool, aim=goal))
</code></pre>
<pre><code>Unsupervised algorithms try to find patterns in the dataset
</code></pre><p>Let&#39;s examine this code below. We have defined a dictionary with keys: tool and goal.</p>
<pre><code class="lang-python">my_methods = {&quot;tool&quot;: &quot;Unsupervised algorithms&quot;, &quot;goal&quot;: &quot;patterns&quot;}
</code></pre>
<p>We want to insert their values in a string. Inside the placeholders, we can specify the value associated with the key tool of the variable data using bracket notation. Data is the dictionary specified in the method, and tool is the key present in that dictionary.</p>
<pre><code class="lang-python">print(&#39;{data[tool]} try to find {data[goal]} in the dataset&#39;.format(data=my_methods))
</code></pre>
<p>So, we get the desired output shown below. Be careful! You need to specify the index without using quotes.</p>
<pre><code>Unsupervised algorithms try to find patterns in the dataset
</code></pre><h2 id="format-specifier">Format Specifier</h2>
<p>We can also specify the format specifies inside curly braces. This defines how individual values are presented. Here, we’ll use the syntax index colon specifier. One of the most common format specifiers is float represented by <code>f</code>. In the code, we specify that the value passed with the index 0 will be a float.</p>
<pre><code class="lang-python">print(&quot;Only {0:f}% of the {1} produced worldwide is {2}!&quot;. format(0.5155675, &quot;data&quot;, &quot;analyzed&quot;))
</code></pre>
<pre><code>Only 0.515567% of the data produced worldwide is analyzed!
</code></pre><p>We could also add <code>.2f</code> indicating that we want the float to have two decimals, as seen in the resulting output.</p>
<pre><code class="lang-python">print(&quot;Only {0:.2f}% of the {1} produced worldwide is {2}!&quot;.format(0.5155675, &quot;data&quot;, &quot;analyzed&quot;))
</code></pre>
<pre><code>Only 0.52% of the data produced worldwide is analyzed!
</code></pre><h2 id="formatting-datetime-">Formatting <code>datetime</code></h2>
<p>Python has a module called <a href="https://www.datacamp.com/community/tutorials/python-datetime">datetime</a> that allows us to, for example, to get the time and date for today.</p>
<pre><code class="lang-python">from datetime import datetime
print(datetime.now())
</code></pre>
<pre><code>2020-08-08 06:28:42.715243
</code></pre><p>But since the format returned is very particular, you could use the format specifier such as <code>%y-%m-%d-%h-%m</code> to adjust the format to something more familiar to us!</p>
<pre><code class="lang-python">print(&quot;Today&#39;s date is {:%Y-%m-%d %H:%M}&quot;.format(datetime.now()))
</code></pre>
<pre><code>Today&#39;s date is 2020-08-08 06:29
</code></pre><h2 id="interactive-example">Interactive Example</h2>
<p>In the following example, you will assign the substrings going from the 4th to the 19th character, and from the 22nd to the 44th character of <code>wikipedia_article</code> to the variables <code>first_pos</code> and <code>second_pos</code>, respectively. Adjust the strings so they are lowercase. Finally, print the variables <code>first_pos</code> and <code>second_pos</code>.</p>
<pre><code class="lang-python"># Assign the substrings to the variables
first_pos = wikipedia_article[3:19].lower()
second_pos = wikipedia_article[21:44].lower()
</code></pre>
<p>When we run the above code, it produces the following result:</p>
<p><code>computer science
artificial intelligence</code></p>
<p><a href="https://campus.datacamp.com/courses/regular-expressions-in-python/formatting-strings?ex=2">Try it for yourself</a>.</p>
<p>To learn more about positional formatting, please see this video from our course, <a href="https://campus.datacamp.com/courses/regular-expressions-in-python/formatting-strings?ex=1">Regular Expressions in Python</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/1Qp_b3yS_YA" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

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


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

(Tutorial) Python String format()

Python String format()

<p>SQL&#39;s &quot;INSERT INTO&quot; statement can be used to add rows of data to a table in the database.</p>
<h3 id="syntax">Syntax</h3>
<p>Below is the normal use case for &quot;INSERT INTO&quot; - where you insert values manually. It is followed by the table name and an optional list of columns that should be filled with the data. Then follows the &quot;VALUES&quot; keyword and the actual values you want to insert.</p>
<pre><code class="lang-sql">INSERT INTO table_name (column_a, column_b)
VALUES (&quot;value_a&quot;, &quot;value_b&quot;);
</code></pre>
<h2 id="insert-distinct-records-into-new-tables">INSERT DISTINCT Records INTO New Tables</h2>
<p>In order to copy data from an existing table to a new one, you can use the &quot;INSERT INTO SELECT DISTINCT&quot; pattern. After &quot;INSERT INTO&quot;, you specify the target table&#39;s name - <code>organizations</code> in the below case.</p>
<p>Then you select the columns that should be copied over from the source table – <code>unviversity_professors</code> in this case. You use the &quot;DISTINCT&quot; keyword to only copy over distinct organizations.</p>
<pre><code class="lang-SQL">INSERT INTO organizations
SELECT DISTINCT organization,
    organization_sector
FROM university_professors;
</code></pre>
<pre><code>Output: INSERT 0 1287
</code></pre><p>The above output shows that only 1287 records are inserted into the &quot;organizations&quot; table.</p>
<p>On the other hand, if you use &quot;INSERT INTO SELECT&quot;, without the &quot;DISTINCT&quot; keyword, duplicate records would be copied over as well.</p>
<pre><code class="lang-SQL">INSERT INTO organizations
SELECT organization,
    organization_sector
FROM university_professors;
</code></pre>
<pre><code>Output: INSERT 0 1377
</code></pre><h2 id="migrating-data-into-a-new-table">Migrating Data Into a New Table</h2>
<p>Let&#39;s migrate the data into new tables. You&#39;ll use the following pattern:</p>
<pre><code class="lang-sql">INSERT INTO ...
SELECT DISTINCT ...
FROM ...;
</code></pre>
<p>It can be broken up into two parts:</p>
<h4 id="first-part-">First part:</h4>
<pre><code class="lang-sql">SELECT DISTINCT column_name1, column_name2, ...
FROM table_a;
</code></pre>
<p>This selects all distinct values in table <code>table_a</code> – nothing new for you.</p>
<pre><code class="lang-SQL">-- Insert unique professors into the new table
INSERT INTO professors
SELECT DISTINCT firstname, lastname, university_shortname
FROM university_professors;

-- Doublecheck the contents of professors
SELECT *
FROM professors;
</code></pre>
<h4 id="second-part-">Second part:</h4>
<pre><code class="lang-sql">INSERT INTO table_b ...;
</code></pre>
<p>Take this part and append it to the first, so it inserts all distinct rows from <code>table_a</code> into <code>table_b</code>.</p>
<p><strong>One last thing</strong>: It is important that you run all of the code at the same time once you have filled out the blanks.</p>
<pre><code class="lang-sql">-- Insert unique affiliations into the new table
INSERT INTO affiliations
SELECT DISTINCT firstname, lastname, function, organization
FROM university_professors;

-- Doublecheck the contents of affiliations
SELECT *
FROM affiliations;
</code></pre>
<p><a href="https://campus.datacamp.com/courses/introduction-to-relational-databases-in-sql/your-first-database?ex=9">Try it for yourself</a>.</p>
<p>To learn more about relational databases in SQL, please see this video from our course <a href="https://campus.datacamp.com/courses/introduction-to-relational-databases-in-sql/your-first-database?ex=7">Introduction to Relational Databases in SQL</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/j_qNFvuyh0I?start=66" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

<p>This content is taken from DataCamp’s <a href="https://www.datacamp.com/courses/introduction-to-python-for-finance">Introduction to Relational Databases in SQL</a> course by Timo Grossenbacher.</p>


https://www.datacamp.com/community/tutorials/insert-into-sql

(Tutorial) Insert Into SQL

Insert Into SQL

<p>A database models real-life entities like professors and universities by storing them in tables. Each table contains data from a single entity type. This reduces redundancy by storing entities only once. For example, there only needs to be one row of data containing a certain company&#39;s details. Lastly, a database can be used to model the relationship between entities.</p>
<p>SQL is Structured Query Language, which is a computer language for storing, manipulating, and retrieving data stored in a relational database.</p>
<p>SQL is the standard language for Relational Database System. All the Relational Database Management Systems (RDMS) like MySQL, MS Access, Oracle, Sybase, Informix, Postgres, and SQL Server use SQL as their standard database language.</p>
<h2 id="postgresql-database">PostgreSQL Database</h2>
<p><code>information_schema</code> is a meta-database that holds information about your current database. It&#39;s not PostgreSQL specific and also available in other database management systems like MySQL or SQL Server. <code>information_schema</code> has multiple tables you can query with the known <code>SELECT * FROM</code> syntax:</p>
<ul>
<li>tables: information about all tables in your current database</li>
</ul>
<ul>
<li>columns: information about all columns in all of the tables in your current database</li>
</ul>
<pre><code class="lang-SQL">  SELECT table_schema, table_name
  FROM information_schema.tables;
</code></pre>
<pre><code>      table_schema    |              table_name
   -------------------+------------------------------
   pg_catalog         | pg_statistic
   pg_catalog         | pg_type
   pg_catalog         | pg_policy
   pg_catalog         | pg_authid
   pg_catalog         | pg_shadow
   public             | university_professors
   pg_catalog         | pg_settings
  ...
</code></pre><h2 id="commands-in-sql">Commands in SQL</h2>
<h4 id="data-definition-language-ddl-">Data Definition Language (DDL)</h4>
<ul>
<li><strong>CREATE</strong>: It creates a new table, a view of a table.</li>
<li><strong>ALTER</strong>: It modifies the existing table.</li>
<li><strong>DROP</strong>: It deletes the entire table or other objects in the database.</li>
</ul>
<h4 id="data-manipulation-language-dml-">Data Manipulation Language (DML)</h4>
<ul>
<li><strong>SELECT</strong>: It extracts certain records from one or more tables.</li>
<li><strong>INSERT</strong>: It creates a record in the existing table.</li>
<li><strong>UPDATE</strong>: It modifies the existing record of the table.</li>
<li><strong>DELETE</strong>: It deletes the records in the table and even delete the complete table.</li>
</ul>
<h2 id="looking-at-the-columns-of-a-certain-table">Looking at the Columns of a Certain Table</h2>
<p><code>information_schema</code> also holds information about columns in the &quot;columns&quot; table. Once you know the name of a table, you can query its columns by accessing the &quot;columns&quot; table.</p>
<pre><code class="lang-SQL">SELECT table_name, column_name, data_type
FROM information_schema.columns
WHERE table_name = &#39;pg_config&#39;;
</code></pre>
<pre><code class="lang-out"> table_name | column_name | data_type
 -----------+-------------+-----------
 pg_config  | name        | text
 pg_config  | setting     | text
</code></pre>
<p>Here, you see that the system table <code>pg_config</code> has only two columns – supposedly for storing name-value pairs.</p>
<h2 id="interactive-example">Interactive Example</h2>
<p>In this exercise, you&#39;ll only need information from the <code>&#39;public&#39;</code> schema, which is specified as the column <code>table_schema</code> of the <code>tables</code> and <code>columns</code> tables. The <code>&#39;public&#39;</code> schema holds information about user-defined tables and databases. The other types of <code>table_schema</code> hold system information – here, we are only interested in user-defined stuff.</p>
<p>You will get information on all table names in the current database while limiting your query to the <code>&#39;public&#39;</code> <code>table_schema</code>.</p>
<pre><code class="lang-python">## Query the right table in information_schema
SELECT table_name
FROM information_schema.tables
## Specify the correct table_schema value
WHERE table_schema = &#39;public&#39;;
</code></pre>
<p>When we run above code, it produces the following result:</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603468261/sql2_ki8l1w.png" /></center>

<p><a href="https://campus.datacamp.com/courses/introduction-to-relational-databases-in-sql/your-first-database?ex=3">Try it for yourself</a>.</p>
<p>To learn more about relational databases in SQL, please see this video from our course <a href="https://campus.datacamp.com/courses/introduction-to-relational-databases-in-sql/your-first-database?ex=1">Introduction to Relational Databases in SQL</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/dDoFZyUHMVo?start=98" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

<p>This content is taken from DataCamp’s <a href="https://www.datacamp.com/courses/introduction-to-python-for-finance">Introduction to Relational Databases in SQL</a> course by Timo Grossenbacher.</p>


https://www.datacamp.com/community/tutorials/sql-database

(Tutorial) SQL Database Overview

SQL Database Overview

<p>An object-oriented approach is most useful when your code involves complex interactions of many objects. In real production code, classes can have dozens of attributes and methods with complicated logic, but the underlying structure is the same as with the most simple class.</p>
<p>Classes are like a blueprint for objects outlining possible behaviors and states that every object of a certain type could have. For example, if you say, &quot;every customer will have a phone number and an email, and will be able to place and cancel orders&quot;, you just defined a class! This way, you can talk about customers in a unified way. Then a specific Customer object is just a realization of this class with a particular state value.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1603476086/class2_b3ufes.png" /></center>

<h2 id="finding-python-classes">Finding Python Classes</h2>
<p>In Python, everything is an object. Numbers, strings, DataFrames, even functions are objects. In particular, everything you deal with in Python has a class, a blueprint associated with it under the hood. The existence of these unified interfaces is why you can use, for example, any DataFrame in the same way.</p>
<p>You can call <code>type()</code> on any Python object to find out its class. For example, the class of a <code>numpy</code> array is actually called <code>ndarray</code> (for n-dimensional array).</p>
<pre><code class="lang-py">import numpy as np
a = np.array([1,2,3,4])
print(type(a))
</code></pre>
<pre><code>numpy.ndarray
</code></pre><p>Classes incorporate information about state and behavior. State information in Python is contained in attributes and behavior information in methods.</p>
<h2 id="attributes-and-methods">Attributes and Methods</h2>
<p>Take a <code>numpy</code> array: you have already been using some of its methods and attributes!</p>
<p>For example, every <code>numpy</code> array has an attribute &quot;shape&quot; that you can access by specifying the array&#39;s name followed by a dot and shape.</p>
<h3 id="state-attributes">State &lt;--&gt; Attributes</h3>
<pre><code class="lang-py">import numpy as np
a = np.array([1,2,3,4])
</code></pre>
<pre><code class="lang-py"># shape attribute
a.shape
</code></pre>
<pre><code>(4,)
</code></pre><p>It also has methods like <code>max</code> and <code>reshape</code> which are also accessible via dot.</p>
<h3 id="behavior-methods">Behavior &lt;--&gt; Methods</h3>
<pre><code class="lang-py">import numpy as np
a = np.array([1,2,3,4])
</code></pre>
<pre><code class="lang-py"># reshape method
a.reshape(2,2)
</code></pre>
<pre><code>array([[1, 2],
       [3, 4]])
</code></pre><h2 id="creating-your-first-class">Creating Your First Class</h2>
<p>In this example, you will create an empty class <code>Employee</code>. Then you will create an object <code>emp</code> of the class <code>Employee</code> by calling <code>Employee()</code>.</p>
<p>Try printing the <code>.name</code> attribute of <code>emp</code> object in the console. What happens?</p>
<pre><code class="lang-python"># Create an empty class Employee
class Employee:
    pass
# Create an object emp of class Employee
emp = Employee()
</code></pre>
<p><a href="https://campus.datacamp.com/courses/object-oriented-programming-in-python/oop-fundamentals?ex=6">Try it for yourself</a>.</p>
<p>To learn more about object-oriented programming in python, please see this video from our course, <a href="https://campus.datacamp.com/courses/object-oriented-programming-in-python/oop-fundamentals?ex=1">Object-Oriented Programming in Python</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/SV7Is9IPNk8?start=145" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

<p>This content is taken from DataCamp’s <a href="https://www.datacamp.com/courses/data-processing-in-shell">Object-Oriented Programming in Python</a> course by Aliaksandra Yarosh.</p>


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

(Tutorial) Python Classes

Python Classes

<p>The <code>boxplot()</code> function shows how the distribution of a numerical variable <code>y</code> differs across the unique levels of a second variable, <code>x</code>. To be effective, this second variable should not have too many unique levels (e.g., 10 or fewer is good; many more than this makes the plot difficult to interpret).</p>
<p>The <code>boxplot()</code> function also has a number of optional parameters, and this exercise asks you to use three of them to obtain a more informative plot:</p>
<ul>
<li><code>varwidth</code> allows for variable-width Box Plot that shows the different sizes of the data subsets.</li>
<li><code>log</code> allows for log-transformed y-values.</li>
<li><code>las</code> allows for more readable axis labels.</li>
</ul>
<h2 id="when-you-should-use-a-box-plot-">When you should use a Box Plot?</h2>
<ul>
<li><p>When you have a continuous variable, split by a categorical variable.</p>
</li>
<li><p>When you want to compare the distributions of the continuous variable for each category.</p>
</li>
</ul>
<h2 id="histogram-vs-box-plot">Histogram vs. Box Plot</h2>
<ul>
<li>Below is the comparison of a Histogram vs. a Box Plot. The line in the middle shows the median of the distribution. That is, half the monarchs started ruling before this age, and half after this age.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/c_scale,f_auto,q_auto:best/v1601058164/boxplot3_aej9he.png" /></center>


<ul>
<li>The box in the Box Plot extends from the lower quartile to the upper quartile. The lower quartile is the point where one-quarter of the values are below it. That is, one-quarter of the monarchs started ruling before this age, and three-quarters after it. Likewise, the upper quartile is the age where three quarters of the monarchs started ruling below this age. The difference between the upper quartile and the lower quartile is called the inter-quartile range.</li>
</ul>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1601058164/boxplot4_sjwpbm.png" /></center>

<p>The horizontal lines, known as &quot;whiskers&quot;, have a more complicated definition. Each bar extends to one and a half times the interquartile range, but then they are limited to reaching actual data points.</p>
<p>The technical definition is shown in the image below, but in practice, you can think of the whiskers as extending far enough that anything outside of them is an extreme value.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1601058084/Screen_Shot_2020-09-25_at_2.20.50_PM_xizuqo.png" /></center>

<p>As mentioned before, the power of Box Plots is that you can compare many distributions at once. Here, the royal houses are ordered from oldest at the top to newest at the bottom.</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best,w_400/v1601058084/Screen_Shot_2020-09-25_at_2.20.59_PM_ksobqy.png" /></center>

<p>A trend is visible: since the Plantagenets in the fourteenth century, the boxes gradually move right, showing that the ages when new monarchs ascend to the throne have been increasing.</p>
<p>Godwin and Blois appear as a single line because there was only one king from each house. The Anjou house only had three kings, and forms a box with one whisker, not two.</p>
<p>Notice that the Box Plots for the houses of Denmark and Windsor show some points. These are extreme values, that is, values that are outside the range of the whiskers. Windsor&#39;s left-most outlier is Elizabeth the second, who ascended at age 26.</p>
<h2 id="-boxplot-function"><code>boxplot()</code> Function</h2>
<p>In the following example, using the formula interface, you will create a Box Plot showing the distribution of numerical <code>crim</code> values over the different distinct <code>rad</code> values from the <a href="https://www.rdocumentation.org/packages/MASS/topics/Boston">Boston</a> data frame. Then, use the <code>varwidth</code> parameter to obtain variable-width Box Plots, specify a log-transformed y-axis, and set the <code>las</code> parameter equal to 1 to obtain horizontal labels for both the x and y-axes.</p>
<p>Finally, use the <code>title()</code> function to add the title <code>&quot;Crime rate vs. radial highway index&quot;</code>.</p>
<pre><code class="lang-r"># Create a variable-width Box Plot with log y-axis &amp; horizontal labels
boxplot(crim ~ rad, data = Boston,
        varwidth = TRUE, log = &quot;y&quot;, las = 1)

# Add a title
title(&quot;Crime rate vs. radial highway index&quot;)
</code></pre>
<p>When we run the above code, it produces the following result:</p>
<center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best,w_400/v1601058164/boxplot2_rjcbyw.png" /></center>

<p><a href="https://campus.datacamp.com/courses/data-visualization-in-r/different-plot-types?ex=7">Try it for yourself</a>.</p>
<p>To learn more about Box Plots, please see this video from our course <a href="https://campus.datacamp.com/courses/data-visualization-for-everyone/visualizing-distributions?ex=7">Data Visualization for Everyone</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/rs0P8wLLDEQ?start=90" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

<p>This content is taken from DataCamp’s <a href="https://www.datacamp.com/courses/data-visualization-for-everyone">Data Visualization for Everyone</a> course by Richie Cotton and our <a href="https://learn.datacamp.com/courses/data-processing-in-shell">Data Visualization in R</a> course by Ronald Pearson.</p>


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

(Tutorial) Box Plot in R

Box Plot in R

<p>Removing duplicates is an essential skill to get accurate counts because you often don&#39;t want to count the same thing multiple times. In Python, this could be accomplished by using the Pandas module, which has a method known as <code>drop_duplicates</code>.</p>
<p>Let&#39;s understand how to use it with the help of a few examples.</p>
<h2 id="dropping-duplicate-names">Dropping Duplicate Names</h2>
<p>Let&#39;s say you have a dataframe that contains vet visits, and the vet&#39;s office wants to know how many dogs of each breed have visited their office. However, there are dogs like Max and Stella, who have visited the vet more than once in your dataset. Hence, you cannot just count the number of each breed in the breed column.</p>
<pre><code class="lang-python">print(vet_visits)
</code></pre>
<pre><code>          date     name        breed  weight_kg
0   2018-09-02    Bella     Labrador      24.87
1   2019-06-07      Max     Labrador      28.35
2   2018-01-17   Stella    Chihuahua       1.51
3   2019-10-19     Lucy    Chow Chow      24.07
..         ...      ...          ...        ...
71  2018-01-20   Stella    Chihuahua       2.83
72  2019-06-07      Max    Chow Chow      24.01
73  2018-08-20     Lucy    Chow Chow      24.40
74  2019-04-22      Max     Labrador      28.54
</code></pre><p>To achieve this, you would remove rows that contain a dog name already listed earlier, or in other words, you will extract a dog with each name from the dataset once.</p>
<p>You would do this using the <code>drop_duplicates</code> method. It takes an argument <code>subset</code>, which is the column we want to find or duplicates based on - in this case, we want all the unique names.</p>
<pre><code class="lang-python">vet_visits.drop_duplicates(subset=&quot;name&quot;)
</code></pre>
<pre><code>          date     name        breed  weight_kg
0   2018-09-02    Bella     Labrador      24.87
1   2019-06-07      Max    Chow Chow      24.01
2   2019-03-19  Charlie       Poodle      24.95
3   2018-01-17   Stella    Chihuahua       1.51
4   2019-10-19     Lucy    Chow Chow      24.07
7   2019-03-30   Cooper    Schnauzer      16.91
10  2019-01-04   Bernie  St. Bernard      74.98
</code></pre><pre><code>(6  2019-06-07      Max     Labrador      28.35)
</code></pre><p>But, what if we have dogs with the same name?</p>
<h2 id="dropping-duplicate-pairs">Dropping Duplicate Pairs</h2>
<p>In that case, we need to consider more than just <code>name</code> when dropping duplicates. Since <code>Max</code> and <code>Max</code> are different breeds, we can drop the rows with pairs of names and breeds listed earlier in the dataset.</p>
<pre><code class="lang-python">unique_dogs = vet_visits.drop_duplicates(subset=[&quot;name&quot;, &quot;breed&quot;])
print(unique_dogs)
</code></pre>
<pre><code>          date     name        breed  weight_kg
0   2018-09-02    Bella     Labrador      24.87
1   2019-03-13      Max    Chow Chow      24.13
2   2019-03-19  Charlie       Poodle      24.95
3   2018-01-17   Stella    Chihuahua       1.51
4   2019-10-19     Lucy    Chow Chow      24.07
6   2019-06-07      Max     Labrador      28.35
7   2019-03-30   Cooper    Schnauzer      16.91
10  2019-01-04   Bernie  St. Bernard      74.98
</code></pre><p>To base our duplicate dropping on multiple columns, we can pass a list of column names to the subset argument, in this case, name and breed.</p>
<p>Now both Max&#39;s have been included.</p>
<h2 id="interactive-example">Interactive Example</h2>
<p>In this exercise, you&#39;ll create some new DataFrames using unique values from <code>sales</code>. <code>sales</code> is available, and <code>pandas</code> is imported as <code>pd</code>.</p>
<p>You will perform the following steps:</p>
<ul>
<li>First, you will remove rows of <code>sales</code> with duplicate pairs of <code>store</code> and <code>type</code> and save as <code>store_types</code> and print the head.</li>
<li>Then, you will remove rows of <code>sales</code> with duplicate pairs of <code>store</code> and <code>department</code> and save as <code>store_depts</code> and print the head.</li>
<li>Subset the rows that are holiday weeks, and drop the duplicate <code>dates</code>, saving as <code>holiday_dates</code>.</li>
<li>Finally, select the <code>date</code> column of <code>holiday_dates</code>, and print the <code>holiday_dates</code> dataframe.</li>
</ul>
<pre><code class="lang-python"># Drop duplicate store/type combinations
store_types = sales.drop_duplicates(subset=[&quot;store&quot;, &quot;type&quot;])
print(store_types.head())

# Drop duplicate store/department combinations
store_depts = sales.drop_duplicates(subset=[&quot;store&quot;, &quot;department&quot;])
print(store_depts.head())

# Subset the rows that are holiday weeks and drop duplicate dates
holiday_dates = sales[sales[&quot;is_holiday&quot;]].drop_duplicates(subset=&quot;date&quot;)

# Print date col of holiday_dates
print(holiday_dates[&quot;date&quot;])
</code></pre>
<p>When we run the above code, it produces the following result:</p>
<pre><code>      store type  department       date  weekly_sales  is_holiday  temperature_c  fuel_price_usd_per_l  unemployment
0         1    A           1 2010-02-05      24924.50       False          5.728                 0.679         8.106
901       2    A           1 2010-02-05      35034.06       False          4.550                 0.679         8.324
1798      4    A           1 2010-02-05      38724.42       False          6.533                 0.686         8.623
2699      6    A           1 2010-02-05      25619.00       False          4.683                 0.679         7.259
3593     10    B           1 2010-02-05      40212.84       False         12.411                 0.782         9.765
    store type  department       date  weekly_sales  is_holiday  temperature_c  fuel_price_usd_per_l  unemployment
0       1    A           1 2010-02-05      24924.50       False          5.728                 0.679         8.106
12      1    A           2 2010-02-05      50605.27       False          5.728                 0.679         8.106
24      1    A           3 2010-02-05      13740.12       False          5.728                 0.679         8.106
36      1    A           4 2010-02-05      39954.04       False          5.728                 0.679         8.106
48      1    A           5 2010-02-05      32229.38       False          5.728                 0.679         8.106
498    2010-09-10
691    2011-11-25
2315   2010-02-12
6735   2012-09-07
6810   2010-12-31
6815   2012-02-10
6820   2011-09-09
Name: date, dtype: datetime64[ns]
</code></pre><p><a href="https://campus.datacamp.com/courses/data-manipulation-with-pandas/aggregating-data-848344db-cbd9-4b34-a95f-949ce8af06c2?ex=7">Try it for yourself</a>.</p>
<p>To learn more about counting and aggregating data, please see this video from our course <a href="https://campus.datacamp.com/courses/data-manipulation-with-pandas/aggregating-data-848344db-cbd9-4b34-a95f-949ce8af06c2?ex=6">Data Manipulation with pandas</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/IbRokvcf6Ow?start=19" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

<p>This content is taken from DataCamp’s <a href="https://learn.datacamp.com/courses/data-manipulation-with-pandas">Data Manipulation with pandas</a> course by Maggie Matsui and Richie Cotton.</p>


https://www.datacamp.com/community/tutorials/pandas-drop-duplicates

(Tutorial) Pandas Drop Duplicates

Pandas Drop Duplicates

<p>Finding interesting bits of data in a DataFrame is often easier if you change the rows&#39; order. You can sort the rows by passing a column name to <code>.sort_values()</code>.</p>
<p>In cases where rows have the same value (this is common if you sort on a categorical variable), you may wish to break the ties by sorting on another column. You can sort on multiple columns in this way by passing a list of column names.</p>
<br><center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1601054651/37_fa9fh6.png" /></center>


<h2 id="modifying-the-order-of-columns">Modifying the Order of Columns</h2>
<p>You can change the rows&#39; order by sorting them so that the most interesting data is at the top of the dataframe.</p>
<p>For example, when we apply <code>sort_values()</code> on the <code>weight_kg</code> column of the dogs dataframe, we get the lightest dog at the top, Stella the Chihuahua, and the heaviest dog at the bottom, Bernie the Saint Bernard.</p>
<pre><code class="lang-python">dogs.sort_values(&quot;weight_kg&quot;)
</code></pre>
<pre><code>      name        breed  color  height_cm  weight_kg date_of_birth
5   Stella    Chihuahua    Tan         18          2    2015-04-20
3   Cooper    Schnauzer   Gray         49         17    2011-12-11
0    Bella     Labrador  Brown         56         24    2013-07-01
1  Charlie       Poodle  Black         43         24    2016-09-16
2     Lucy    Chow Chow  Brown         46         24    2014-08-25
4      Max     Labrador  Black         59         29    2017-01-20
6   Bernie  St. Bernard  White         77         74    2018-02-27
</code></pre><p>Setting the <code>ascending</code> argument to False will sort the data the other way round, from heaviest to lightest dog.</p>
<pre><code class="lang-python">dogs.sort_values(&quot;weight_kg&quot;, ascending=False)
</code></pre>
<pre><code>      name        breed  color  height_cm  weight_kg date_of_birth
6   Bernie  St. Bernard  White         77         74    2018-02-27
4      Max     Labrador  Black         59         29    2017-01-20
0    Bella     Labrador  Brown         56         24    2013-07-01
1  Charlie       Poodle  Black         43         24    2016-09-16
2     Lucy    Chow Chow  Brown         46         24    2014-08-25
3   Cooper    Schnauzer   Gray         49         17    2011-12-11
5   Stella    Chihuahua    Tan         18          2    2015-04-20
</code></pre><h2 id="sorting-by-multiple-variables">Sorting by Multiple Variables</h2>
<p>We can sort by multiple variables by passing a list of column names to <code>sort_values</code>. Here, we sort first by weight, then by height. Now, Charlie, Lucy, and Bella are ordered from shortest to tallest, even though they all weigh the same.</p>
<pre><code class="lang-python">dogs.sort_values([&quot;weight_kg&quot;, &quot;height_cm&quot;])
</code></pre>
<pre><code>      name        breed  color  height_cm  weight_kg date_of_birth
5   Stella    Chihuahua    Tan         18          2    2015-04-20
3   Cooper    Schnauzer   Gray         49         17    2011-12-11
1  Charlie       Poodle  Black         43         24    2016-09-16
2     Lucy    Chow Chow  Brown         46         24    2014-08-25
0    Bella     Labrador  Brown         56         24    2013-07-01
4      Max     Labrador  Black         59         29    2017-01-20
6   Bernie  St. Bernard  White         77         74    2018-02-27
</code></pre><p>To change the direction values are sorted in, pass a list to the ascending argument to specify which direction sorting should be done for each variable. Now, Charlie, Lucy, and Bella are ordered from tallest to shortest.</p>
<pre><code class="lang-python">dogs.sort_values([&quot;weight_kg&quot;, &quot;height_cm&quot;], ascending=[True, False])
</code></pre>
<pre><code>      name        breed  color  height_cm  weight_kg date_of_birth
5   Stella    Chihuahua    Tan         18          2    2015-04-20
3   Cooper    Schnauzer   Gray         49         17    2011-12-11
0    Bella     Labrador  Brown         56         24    2013-07-01
2     Lucy    Chow Chow  Brown         46         24    2014-08-25
1  Charlie       Poodle  Black         43         24    2016-09-16
4      Max     Labrador  Black         59         29    2017-01-20
6   Bernie  St. Bernard  White         77         74    2018-02-27
</code></pre><h2 id="interactive-example">Interactive Example</h2>
<p>In the following example, you will sort <code>homelessness</code> by the number of homeless individuals, from smallest to largest, and save this as <code>homelessness_ind</code>. Finally, you will print the head of the sorted DataFrame.</p>
<pre><code class="lang-python"># Sort homelessness by individuals
homelessness_ind = homelessness.sort_values(&quot;individuals&quot;)

# Print the top few rows
print(homelessness_ind.head())
</code></pre>
<p>When we run the above code, it produces the following result:</p>
<pre><code>                region         state  individuals  family_members  state_pop
50            Mountain       Wyoming        434.0           205.0     577601
34  West North Central  North Dakota        467.0            75.0     758080
7       South Atlantic      Delaware        708.0           374.0     965479
39         New England  Rhode Island        747.0           354.0    1058287
45         New England       Vermont        780.0           511.0     624358
</code></pre><p><a href="https://campus.datacamp.com/courses/data-manipulation-with-pandas/transforming-data?ex=5">Try it for yourself</a>.</p>
<p>To learn more about sorting and subsetting the data, please see this video from our course <a href="https://campus.datacamp.com/courses/data-manipulation-with-pandas/transforming-data?ex=4">Data Manipulation with pandas</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/F0tQ1YG6BWQ" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

<p>This content is taken from DataCamp’s <a href="https://www.datacamp.com/courses/data-manipulation-with-pandas">Data Manipulation with pandas</a> course by Maggie Matsui and Richie Cotton.</p>


https://www.datacamp.com/community/tutorials/pandas-sort-values

(Tutorial) Pandas Sort Values

Pandas Sort Values

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

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

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

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

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


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

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

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

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

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

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

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

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


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

<p>This content is taken from DataCamp’s <a href="https://www.datacamp.com/courses/introduction-to-data-visualization-with-ggplot2">Introduction to Data Visualization with ggplot2</a> course by Rick Scavetta.</p>


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

(Tutorial) Graphics with ggplot2

Graphics with ggplot2

<p>You are never stuck with just the data you are given. Instead, you can add new columns to a DataFrame. This has many names, such as <em>transforming</em>, <em>mutating</em>, and <em>feature engineering</em>.</p>
<p>You can create new columns from scratch, but it is also common to derive them from other columns, for example, by adding columns together or by changing their units.</p>
<h2 id="deriving-a-column">Deriving a Column</h2>
<p>Using a dog dataset, let&#39;s say you want to add a new column to your DataFrame that has each dog&#39;s height in meters instead of centimeters.</p>
<p>On the left-hand side of the equals, you use square brackets with the name of the new column you want to create, in this case, <code>height_m</code>. On the right-hand side, you have the calculation.</p>
<pre><code class="lang-python">dogs[&quot;height_m&quot;] = dogs[&quot;height_cm&quot;] / 100
print(dogs)
</code></pre>
<pre><code>        name        breed   color   height_cm   weight_kg   date_of_birth   height_m
0      Bella     Labrador   Brown          56          24      2013-07-01       0.56
1    Charlie       Poodle   Black          43          24      2016-09-16       0.43
2       Lucy    Chow Chow   Brown          46          24      2014-08-25       0.46
3     Cooper    Schnauzer    Gray          49          17      2016-09-16       0.49
4        Max     Labrador   Black          59          29      2016-09-16       0.59
5     Stella    Chihuahua     Tan          18           2      2016-09-16       0.18
6     Bernie  St. Bernard   White          77          74      2016-09-16       0.77
</code></pre><p>Notice that both the existing and the derived column are in the dataframe you modified.</p>
<h2 id="adding-a-column">Adding a Column</h2>
<p>In this example, you will calculate doggy mass index and add it as a column to your dataframe. BMI stands for body mass index, which is calculated by weight in kilograms divided by their height in meters, squared.</p>
<pre><code class="lang-python">dogs[&quot;height_m&quot;] = dogs[&quot;weight_kg&quot;] / dogs[&quot;height_m&quot;] ** 2
print(dogs.head())
</code></pre>
<pre><code>        name        breed   color   height_cm   weight_kg   date_of_birth   height_m          bmi
0      Bella     Labrador   Brown          56          24      2013-07-01       0.56    76.530612
1    Charlie       Poodle   Black          43          24      2016-09-16       0.43   129.799892
2       Lucy    Chow Chow   Brown          46          24      2014-08-25       0.46   113.421550
3     Cooper    Schnauzer    Gray          49          17      2016-09-16       0.49    70.803832
4        Max     Labrador   Black          59          29      2016-09-16       0.59    83.309394
</code></pre><p>Again, the new column is on the left-hand side of the equals, but this time, our calculation involves two columns.</p>
<h2 id="adding-a-column-with-multiple-manipulations">Adding a Column With Multiple Manipulations</h2>
<p>The real power of pandas comes in when you combine all the skills that you have learned so far. Let&#39;s figure out the names of skinny, tall dogs.</p>
<p>First, to define the skinny dogs, you take the subset of dogs that have a BMI of less than 100. Next, you sort the height in descending order of height to get the tallest skinny dogs at the top.</p>
<p>Finally, this time you will only keep the columns you are interested in.</p>
<pre><code class="lang-python">bmi_lt_100 = dogs[dogs[&quot;bmi&quot;] &lt; 100]
bmi_lt_100_height = bmi_lt_100.short_values(&quot;height_cm&quot;, ascending=False)
bmi_lt_100_height[[&quot;name&quot;, &quot;height_cm&quot;, &quot;bmi&quot;]]
</code></pre>
<pre><code>        name      height_cm           bmi
4        Max             59     83.309394
0      Bella             56     76.530612
3     Cooper             49     70.803832
5     Stella             18     61.728395
</code></pre><p>Here, you can see that <code>Max</code> is the tallest dog with a BMI of under 100.</p>
<h2 id="interactive-example">Interactive Example</h2>
<p>In the below example, you add a new column to DataFrame <code>homelessness</code>, named <code>total</code>, containing the sum of the <code>individuals</code> and <code>family_members</code> columns. Then, add another column to <code>homelessness</code>, named <code>p_individuals</code>, containing the proportion of homeless people in each state who are individuals. Finally, print the <code>homelessness</code> dataframe.</p>
<pre><code class="lang-python"># Add total col as sum of individuals and family_members
homelessness[&quot;total&quot;] = homelessness[&quot;individuals&quot;] + homelessness[&quot;family_members&quot;]

# Add p_individuals col as proportion of individuals
homelessness[&quot;p_individuals&quot;] = homelessness[&quot;individuals&quot;] / homelessness[&quot;total&quot;]

# See the result
print(homelessness)
</code></pre>
<p>When we run the above code, it produces the following result:</p>
<pre><code>                region                 state  individuals  family_members  state_pop     total  p_individuals
0   East South Central               Alabama       2570.0           864.0    4887681    3434.0          0.748
1              Pacific                Alaska       1434.0           582.0     735139    2016.0          0.711
2             Mountain               Arizona       7259.0          2606.0    7158024    9865.0          0.736
3   West South Central              Arkansas       2280.0           432.0    3009733    2712.0          0.841
4              Pacific            California     109008.0         20964.0   39461588  129972.0          0.8
...
48      South Atlantic         West Virginia       1021.0           222.0    1804291    1243.0          0.821
49  East North Central             Wisconsin       2740.0          2167.0    5807406    4907.0          0.558
50            Mountain               Wyoming        434.0           205.0     577601     639.0          0.679
</code></pre><p><a href="https://campus.datacamp.com/courses/data-manipulation-with-pandas/transforming-data?ex=10">Try it for yourself</a>.</p>
<p>To learn more about adding new columns in pandas, please see this video from our course <a href="https://campus.datacamp.com/courses/data-manipulation-with-pandas/transforming-data?ex=9">Data Manipulation with pandas
</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/w-pGkEvGYao?start=17" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

<p>This content is taken from DataCamp’s <a href="https://learn.datacamp.com/courses/data-types-for-data-science-in-python">Data Manipulation with pandas</a> course by Maggie Matsui and Richie Cotton.</p>


https://www.datacamp.com/community/tutorials/pandas-add-column

(Tutorial) Pandas Add Column

Pandas Add Column

<p>If you are looking to find or replace items in a string, Python has several built-in methods that can help you search a target string for a specified substring.</p>
<h2 id="-find-method"><code>.find()</code> Method</h2>
<h3 id="syntax">Syntax</h3>
<pre><code class="lang-Python">string.find(substring, start, end)
</code></pre>
<p>Note: <code>start</code> and <code>end</code> are optional arguments.</p>
<p>From the above syntax, you can observe that the <code>.find()</code> method takes the desired substring as the mandatory argument. You can specify the other two arguments: an inclusive starting position and an exclusive ending position.</p>
<h3 id="substring-search">Substring Search</h3>
<p>In the example code, you search for <code>Waldo</code> in the string <code>Where&#39;s Waldo?</code>. The <code>.find()</code> method returns the lowest index in the string where it can find the substring, in this case, eight.</p>
<pre><code class="lang-python">my_string = &quot;Where&#39;s Waldo?&quot;
my_string.find(&quot;Waldo&quot;)
</code></pre>
<pre><code>8
</code></pre><p>If you search for <code>Wenda</code>, it returns <code>-1</code> since the substring is not found.</p>
<pre><code class="lang-python">my_string.find(&quot;Wenda&quot;)
</code></pre>
<pre><code>-1
</code></pre><p>Let&#39;s see if you can find <code>Waldo</code> between characters zero and five. In the code, you specify the starting position zero and ending position as six, since this position is not inclusive.</p>
<pre><code class="lang-python">my_string = &quot;Where&#39;s Waldo?&quot;
</code></pre>
<pre><code class="lang-python">my_string.find(&quot;Waldo&quot;, 0, 6)
</code></pre>
<pre><code class="lang-out">-1
</code></pre>
<p>The <code>.find()</code> method does not find the substring and returns <code>-1</code>, as shown above.</p>
<h2 id="-index-method"><code>.index()</code> Method</h2>
<h3 id="syntax">Syntax</h3>
<pre><code class="lang-Python">string.index(substring, start, end)
</code></pre>
<p>Note: <code>start</code> and <code>end</code> are optional arguments.</p>
<p>From the above syntax, you can observe that the <code>.index()</code> method takes the desired substring as a mandatory argument. It can take optional starting and ending positions as well.</p>
<h3 id="substring-search">Substring Search</h3>
<p>In the example, we search again for Waldo using <code>.index()</code>.</p>
<pre><code class="lang-Python">my_string = &quot;Where&#39;s Waldo?&quot;
my_string.index(&quot;Waldo&quot;)
</code></pre>
<pre><code>8
</code></pre><p>We get eight again. When we look for a substring that is not there, we have a difference.</p>
<pre><code class="lang-Python">my_string.index(&quot;Wenda&quot;)
</code></pre>
<pre><code>File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
ValueError: substring not found
</code></pre><p>The <code>.index()</code> method raises an exception, as we can see in the output. We can handle this using the try except block.</p>
<pre><code class="lang-python">my_string = &quot;Where&#39;s Waldo?&quot;
</code></pre>
<pre><code class="lang-python">try:
    my_string.index(&quot;Wenda&quot;)
except ValueError:
      print(&quot;Not found&quot;)
</code></pre>
<p>Above, you can observe the syntax. The try part will test the given code. If any error appears, the except part will be executed, obtaining the following output as a result.</p>
<pre><code>&quot;Not found&quot;
</code></pre><h2 id="-count-method"><code>.count()</code> Method</h2>
<p>The <code>.count()</code> method searches for a specified substring in the target string. It returns the number of non-overlapping occurrences. In simple words, how many times the substring is present in the string.</p>
<h3 id="syntax">Syntax</h3>
<p>The syntax of <code>.count()</code> is very similar to the other methods, as we can observe.</p>
<pre><code class="lang-Python">string.count(substring, start, end)
</code></pre>
<p>Note: <code>start</code> and <code>end</code> are optional arguments.</p>
<h3 id="substring-count">Substring Count</h3>
<p>In the example, we use the <code>.count()</code> method to get how many times fruit appears.</p>
<pre><code class="lang-python">my_string = &quot;How many fruits do you have in your fruit basket?&quot;
my_string.count(&quot;fruit&quot;)
</code></pre>
<pre><code>2
</code></pre><p>In the output, we see that is is two.</p>
<p>We can then limit the occurrences of fruit between character zero and fifteen of the string, as we can observe in the code below.</p>
<pre><code class="lang-python">my_string.count(&quot;fruit&quot;, 0, 16)
</code></pre>
<pre><code>1
</code></pre><p>The method will return <code>1</code>. Remember that the starting position is inclusive, but the ending is not.</p>
<h2 id="-replace-method"><code>.replace</code> Method</h2>
<p>Sometimes you will want to replace occurrences of a substring with a new substring. In this case, Python provides us with the <code>.replace</code> method.</p>
<h3 id="syntax">Syntax</h3>
<pre><code class="lang-Python">string.replace(old, new, count)
</code></pre>
<p>Note: <code>count</code> is an optional argument.</p>
<p>As we see in the syntax above, it takes three arguments: the substring being replaced, the new string to replace it, and an optional number that indicates how many occurrences to replace.</p>
<h3 id="replacing-a-substring">Replacing a Substring</h3>
<p>In the example code, we replace the substring house with car.</p>
<pre><code class="lang-python">my_string = &quot;The red house is between the blue house and the old house&quot;
print(my_string.replace(&quot;house&quot;, &quot;car&quot;))
</code></pre>
<pre><code>The red car is between the blue car and the old car
</code></pre><p>The method will return a copy with all house substrings replaced.</p>
<h3 id="replacing-a-specific-number-of-occurrences">Replacing a Specific Number of Occurrences</h3>
<p>In this example, we specified that we only want 2 of the occurrences to be replaced.</p>
<pre><code class="lang-python">print(my_string.replace(&quot;house&quot;, &quot;car&quot;, 2))
</code></pre>
<pre><code>The red car is between the blue car and the old house
</code></pre><p>In the output, we see that the method returns a copy of the string with the first two occurrences of house replaced by car.</p>
<h2 id="interactive-example">Interactive Example</h2>
<p>In the below example, you will:</p>
<ul>
<li>Find if the substring <code>actor</code> occurs between the characters with index <code>37</code> and <code>41</code> inclusive. If it is not detected, print the statement <code>Word not found</code>.</li>
<li>Replace <code>actor actor</code> with the substring <code>actor</code> if <code>actor</code> occurs only two repeated times.</li>
<li>Replace <code>actor actor actor</code> with the substring actor if <code>actor</code> appears three repeated times.</li>
</ul>
<pre><code class="lang-Python">for movie in movies:
      # Find if actor occurrs between 37 and 41 inclusive
    if movie.find(&quot;actor&quot;, 37, 42) == -1:
        print(&quot;Word not found&quot;)
    # Count occurrences and replace two by one
    elif movie.count(&quot;actor&quot;) == 2:  
        print(movie.replace(&quot;actor actor&quot;, &quot;actor&quot;))
    else:
        # Replace three occurrences by one
        print(movie.replace(&quot;actor actor actor&quot;, &quot;actor&quot;))
</code></pre>
<p>When we run the above code, it produces the following result:</p>
<pre><code>Word not found
I believe you I always said that the actor is amazing in every movie he has played
it&#39;s astonishing how frightening the actor norton looks with a shaved head and a swastika on his chest.
</code></pre><p><a href="https://campus.datacamp.com/courses/regular-expressions-in-python/basic-concepts-of-string-manipulation?ex=10">Try it for yourself</a>.</p>
<p>To learn more about finding and replacing strings, please see this video from our course, <a href="https://campus.datacamp.com/courses/regular-expressions-in-python/basic-concepts-of-string-manipulation?ex=9">Regular Expressions in Python</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/bJu-lc5coZw?start=16" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

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


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

(Tutorial) Python String Contains

Python String Contains

<p>One alternative to using a loop to iterate over a DataFrame is to use the pandas <code>.apply()</code> method. This function acts as a <code>map()</code> function in Python. It takes a function as an input and applies this function to an entire DataFrame.</p>
<p>If you are working with tabular data, you must specify an axis you want your function to act on (<code>0</code> for columns; and <code>1</code> for rows).</p>
<p>Much like the <code>map()</code> function, the <code>apply()</code> method can also be used with anonymous functions or lambda functions. Let&#39;s look at some <code>apply()</code> examples using baseball data.</p>
<h2 id="calculating-run-differentials-with-apply-">Calculating Run Differentials With <code>.apply()</code></h2>
<p>First, you will call the <code>.apply()</code> method on the <code>basebal_df</code> dataframe. Then use the <code>lambda</code> function to iterate over the rows of the dataframe. For every row, we grab the <code>RS</code> and <code>RA</code> columns and pass them to the <code>calc_run_diff</code> function. Finally, you will specify the <code>axis=1</code> to tell the <code>.apply()</code> method that we want to apply it on the rows instead of columns.</p>
<pre><code class="lang-python">baseball_df.apply(
    lambda row: calc_run_diff(row[&#39;RS&#39;], row[&#39;RA&#39;]),
    axis=1
)
</code></pre>
<p>You will notice that we don&#39;t need to use a <code>for</code> loop. You can collect the run differentials directly into an object called <code>run_diffs_apply</code>. After creating a new column and printing the dataframe you will notice that the results are similar to what you will get with the <code>.iterrows()</code> method.</p>
<pre><code class="lang-python">run_diffs_apply = baseball_df.apply(
         lambda row: calc_run_diff(row[&#39;RS&#39;], row[&#39;RA&#39;]),
         axis=1)
baseball_df[&#39;RD&#39;] = run_diffs_apply
print(baseball_df)
</code></pre>
<pre><code>      Team    League    year   RS    RA    W    G   Playoffs    RD
0      ARI        NL    2012  734   688   81  162          0    46
1      ATL        NL    2012  700   600   94  162          1   100
2      BAL        AL    2012  712   705   93  162          1     7
</code></pre><h2 id="interactive-example-using-apply-">Interactive Example Using <code>.apply()</code></h2>
<p>The Tampa Bay Rays want you to analyze their data.</p>
<p>They&#39;d like the following metrics:</p>
<ul>
<li>The sum of each column in the data</li>
<li>The total amount of runs scored in a year (<code>&#39;RS&#39;</code> + <code>&#39;RA&#39;</code> for each year)</li>
<li>The <code>&#39;Playoffs&#39;</code> column in text format rather than using <code>1&#39;s</code> and <code>0&#39;s</code></li>
</ul>
<p>The below function can be used to convert the <code>&#39;Playoffs&#39;</code> column to text:</p>
<pre><code class="lang-python">def text_playoffs(num_playoffs):
    if num_playoffs == 1:
        return &#39;Yes&#39;
    else:
      return &#39;No&#39;
</code></pre>
<p>Use <code>.apply()</code> to get these metrics. A DataFrame (<code>rays_df</code>) has been printed below. This DataFrame is indexed on the <code>&#39;Year&#39;</code> column.</p>
<pre><code>       RS   RA   W  Playoffs
2012  697  577  90         0
2011  707  614  91         1
2010  802  649  96         1
2009  803  754  84         0
2008  774  671  97         1
</code></pre><ul>
<li>Apply <code>sum()</code> to each column of the <code>rays_df</code> to collect the sum of each column. Be sure to specify the correct <code>axis</code>.</li>
</ul>
<pre><code class="lang-Python"># Gather sum of all columns
stat_totals = rays_df.apply(sum, axis=0)
print(stat_totals)
</code></pre>
<p>When we run the above code, it produces the following result:</p>
<pre><code>RS          3783
RA          3265
W            458
Playoffs       3
dtype: int64
</code></pre><p><a href="https://campus.datacamp.com/courses/writing-efficient-python-code/basic-pandas-optimizations?ex=8">Try it for yourself</a>.</p>
<p>To learn more about pandas alternative to looping, please see this video from our course <a href="https://campus.datacamp.com/courses/writing-efficient-python-code/basic-pandas-optimizations?ex=7">Writing Efficient Python Code</a>.</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/v6yf43eOqjM?start=90" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

<p>This content is taken from DataCamp’s <a href="https://learn.datacamp.com/courses/intermediate-python-for-data-science">Writing Efficient Python Code</a> course by Logan Thomas.</p>


https://www.datacamp.com/community/tutorials/pandas-apply

community

datacamp

Tutorials