<p>Python is the most popular programming language today and is widely used across verticals from software and web development to game development, IoT and more. More importantly, it’s become the de facto programming language for data science and machine learning. This blog post will outline why and when to use Python, how to install it, basic Python syntax and functionality, an introduction to simple data analysis, and more.</p>
<h2 id="when-and-why-to-use-python">When and why to use Python</h2>
<p>Python is a highly versatile language with many use cases across verticals. Just like many programming languages, Python is open source and free to use, and contains a large library of tools and packages (more on packages later!) that simplify working with a variety of tasks. Here’s are some verticals where Python is useful:</p>
<h3 id="desktop-and-mobile-software-development">Desktop and Mobile Software Development</h3>
<p>Whether building simple software applications like calculators, or document editors and social networks. Python offers a plethora of tools to prototype, develop, and run desktop or mobile applications.</p>
<h3 id="web-development">Web Development</h3>
<p>Did you know that web applications like Uber, Netflix, and Spotify <a href="https://yourstory.com/mystory/top-twelve-python-applications-real-world-know">were built with Python</a>? There are a variety of web frameworks on Python that simplify website development.</p>
<h3 id="game-development">Game Development</h3>
<p>This may come as a surprise, but games such as The Sims 4 and Civilization IV were built with Python. Many Python libraries exist that streamline prototyping and development of games.</p>
<h3 id="internet-of-things-iot-">Internet of Things (IoT)</h3>
<p>The rise of embedded systems and the internet of things (IoT) has catalyzed innovation and business process improvement across domains. Python offers a set of packages that make it easy to design, create, and deploy an IoT device on <a href="https://www.arduino.cc/">Arduino</a>, <a href="https://www.raspberrypi.org/">Raspberry Pi</a>, and other <a href="https://www.home-assistant.io/integrations/">IoT devices</a> such as Alexa and Google Home.</p>
<h3 id="data-science-and-machine-learning">Data Science and Machine Learning</h3>
<p>Python’s rise in popularity can be attributed to its rich set of packages and tools for data science and machine learning. Python can be used across the data science workflow, from exploratory data analysis, data pre-processing, model building and deployment, and finally to results interpretation and communication. Since Python is used across the data science workflow, it is used by a variety of data roles from data analysts, data scientists, data engineers, machine learning engineers, and more.</p>
<h2 id="how-to-install-python">How to install Python</h2>
<p>Python can be installed in a variety of avenues, depending on if you have a Mac or Windows, or if you want to install it with Anaconda. Since Windows and Mac are installed similarly, the following instructions can apply to both operating systems. If you want a deeper look into installing Python for data science, <a href="https://www.datacamp.com/community/tutorials/python-developer-set-up">check out this article</a>.</p>
<h3 id="mac-and-windows">Mac and Windows</h3>
<p>Go to the Python website, which will send you to the downloads page as seen in the screenshot below. Choose Windows or Mac and click on the download button to access the installer package.</p>
<p><center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1617984299/python1_j4xkeo.png" /></center><br></p>
<h3 id="anaconda">Anaconda</h3>
<p>One of the more convenient ways to install Python for data science is by installing an <a href="https://www.anaconda.com/products/individual">Anaconda</a> distribution, which also installs all relevant data science packages. Follow the link above to install it on either Mac, Windows, or Linux. For a deep dive on installing Anaconda, check out these blog posts for <a href="https://www.datacamp.com/community/tutorials/installing-anaconda-mac-os-x">MacOs</a> and <a href="https://www.datacamp.com/community/tutorials/installing-anaconda-windows">Windows</a>.</p>
<p><center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1617985265/DLanaconda_x9jrol.png" /></center><br></p>
<h2 id="how-to-get-started-with-python-for-data-science">How to get started with Python for data science</h2>
<p>In this section, we will cover how to open Python on Mac and Windows, how to launch the terminal, the basics of Python like print statements and operators, variables and assigning values, data types, packages and how to install them, as well as the popular data science library <code>pandas</code> and how to install it.</p>
<h3 id="1-launching-python">1. Launching Python</h3>
<h4 id="launching-terminal">Launching Terminal</h4>
<p>To launch Python, you will first need to launch your terminal. For both Mac and Windows, you can simply search it on your computer. On Mac, the easiest way is to do a Spotlight Search, which is the magnifying glass icon on the upper right corner of your desktop.</p>
<p><center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1617984299/python2_uasjil.png" /></center><br></p>
<p>Similarly, for Windows, you will search for the command prompt through the start menu, as described in a DataCamp article <a href="https://www.datacamp.com/community/tutorials/running-a-python-script">How to Run Python Scripts</a>. You can also launch the new Windows Terminal after installing and searching for it as mentioned on the Windows blog post <a href="https://devblogs.microsoft.com/commandline/introducing-windows-terminal/">Introducing Windows Terminal</a>. After you launch it, here&#39;s what you will see:</p>
<p><center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1617984299/python3_pv1jvj.png" /></center><br></p>
<h4 id="how-to-open-python-on-mac-windows">How to open Python on Mac + Windows</h4>
<p>After Python installation is complete, you can launch your terminal by simply typing the word ‘python’. This will start up Python and show you the current version you have installed. The three arrows point to the right means you are ready to code in Python!</p>
<p><center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1617984299/python4_gajrzb.png" /></center><br></p>
<h3 id="2-basic-python-syntax">2. Basic Python Syntax</h3>
<p>In the following syntax commands below, you will type the command and then hit <code>enter</code> or <code>return</code> on your keyboard to see the results.</p>
<h4 id="print-statements">Print statements</h4>
<p>Next, you can start your first command in Python. We will start off with the <code>print()</code> statement, which will be typing the word print, followed by parenthesis. The output will be typed within those same parentheses and enclosed by quotes.</p>
<pre><code class="lang-python">print(&quot;Hello, World&quot;)
</code></pre>
<pre><code>Hello, World
</code></pre><h4 id="operators">Operators</h4>
<p>Then, you can perform operations, like +, -, and *.  As you can see, the + adds the two numbers together, the - subtracts the second number from the first number, the * multiples both numbers together.</p>
<pre><code class="lang-python">5 + 5
</code></pre>
<pre><code>10
</code></pre><pre><code class="lang-python">5 - 5
</code></pre>
<pre><code>0
</code></pre><pre><code class="lang-python">5 * 5
</code></pre>
<pre><code>25
</code></pre><h4 id="booleans">Booleans</h4>
<p>The next command is to compare two values. In the case below, we will look at comparing the same two numbers, five and five. The command is asking if 5 is greater than 5, which of course, it is not, so the returned output is <code>False</code>. For booleans, we expect the output to be either true or false.</p>
<pre><code class="lang-python">5 &gt; 5
</code></pre>
<pre><code>False
</code></pre><h4 id="creating-variables-and-assigning-them">Creating variables and assigning them</h4>
<p>In this section, we see that you can assign a number to the name <code>variable_1</code>, and then return it by calling that same <code>variable_1</code> to get the value that you had assigned it:</p>
<pre><code class="lang-python">variable_1 = 100
</code></pre>
<pre><code class="lang-python">variable_1
</code></pre>
<pre><code class="lang-python">100
</code></pre>
<h4 id="lists">Lists</h4>
<pre><code class="lang-python">my_list = [&#39;potato&#39;, 3, 4.02]
</code></pre>
<pre><code class="lang-python">my_list[0]
</code></pre>
<pre><code>‘potato’
</code></pre><p>A list is a data structure in which values can be stored and accessed. The neat thing about lists is that they do not all need to be the same data type. Below, we can see that we have a str, int, and a float, respectively. In order to access the items in the list so that they appear in the output, you can type your list name followed by brackets with the place of the item you want. For example, we append [0] to our listname to return the 1st element in our list as seen below.</p>
<p>For a further exploration into Python lists, see the article <a href="https://www.datacamp.com/community/tutorials/python-list-index">Python List Index()</a>.</p>
<h4 id="data-types">Data types</h4>
<p>Python values can have a variety of forms, including ones like <code>int</code>, <code>float</code>, and <code>str</code>. For example, <code>int</code> represents integers, <code>float</code> represents decimal numbers, and <code>str</code> represents “strings”, or more generally text.</p>
<p>Using the <code>type()</code> function, we will be able to check the type of our values. In this case, we’re looking at three values, including 10, 10.06, and the word ‘tutorial’. The first is an integer, while the second is a float, and the last is a string. Below, we can see the command and its respected data type output.</p>
<pre><code class="lang-python">type(10)
</code></pre>
<pre><code>&lt;class &#39;int&#39;&gt;
</code></pre><pre><code class="lang-python">type(10.06)
</code></pre>
<pre><code>&lt;class &#39;float&#39;&gt;
</code></pre><pre><code class="lang-python">type(&#39;tutorial&#39;)
</code></pre>
<pre><code>&lt;class &#39;str&#39;&gt;
</code></pre><p>For a more in-depth look at data types and how to convert them, you can read the following blog, <a href="https://www.datacamp.com/community/tutorials/python-data-type-conversion">Python Data Type Conversion Tutorial</a>.</p>
<h4 id="packages-and-installation">Packages and installation</h4>
<p><a href="https://docs.python.org/3/installing/index.html">Packages</a> are powerful tools that have preserved functionalities. For example, <code>pandas</code> is a package that lets you work with tabular data in Python—more on that below. Think of them as apps you download on Python that provide a specific functionality. You will want to exit out of Python in your terminal by typing Ctrl + D, and then typing the following command below (for Mac users). Here we’re installing a sample package called SomePackage just to illustrate the installation.</p>
<p><center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1617984300/python10_uwyf92.png" /></center><br></p>
<h4 id="installing-pandas-and-jupyter-notebook">Installing pandas and Jupyter Notebook</h4>
<p><a href="https://www.datacamp.com/community/tutorials/pandas">pandas</a> is perhaps the most used data science library in Python. It allows you to work with tabular data in Python and perform a variety of operations. In some sense, you can consider it as the Excel or spreadsheets of Python. The <a href="https://pandas.pydata.org/">developers of pandas</a> describe it as “a fast, powerful, flexible and easy to use open source data analysis and manipulation tool, built on top of the Python programming language.”</p>
<p>Jupyter notebook is a web application that interprets code, saves text, and displays visualizations. Both Jupyter and pandas are available to launch if you downloaded Anaconda, or you can install them by running the following commands in terminal:</p>
<pre><code class="lang-python">pip install pandas
</code></pre>
<pre><code class="lang-python">pip install notebooks
</code></pre>
<h3 id="3-basic-data-science-with-python">3. Basic data science with Python</h3>
<p>In this section, we’ll cover how to import a popular Python package while assigning it an alias, how to read in a CSV file, how to show your data in something called a DataFrame, and how to visualize a column by using a certain plotting function. We have already learned how to install pandas above, and because Jupyter Notebook is easy to use and works across several computer types, we will use that web application to display the following data science functions with pandas.</p>
<p>You can launch a Jupyter notebook by simply typing <code>jupyter notebook</code> in your terminal.</p>
<p><center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1617990202/jupyter_hello_world2_su37ik.png" /></center><br></p>
<h4 id="importing-packages-with-an-alias">Importing packages with an alias</h4>
<p>Before we begin working with pandas, we need to import it in our environment. Similar to launching an app after installing it, importing a package is simple. We can import pandas and assign an alias to it that is shorter than the original name so that it is easier to work with this package. We will assign pandas as the letters <code>pd</code> instead for shorthand notation—this change is purely optional.</p>
<pre><code class="lang-python">import pandas as pd
</code></pre>
<h4 id="importing-your-data-by-reading-in-a-csv-file">Importing your data by reading in a CSV file</h4>
<p>After you have imported pandas as <code>pd</code>, you can use <code>pd</code> to read in your data, which can be a CSV file. This function is to enclose the CSV file path in quotes, within the parentheses of <code>pd.read_csv()</code>. You can then store your CSV to a dataframe with the = operation. You will now be able to print out your dataframe, but you will only want to see the first rows instead of all of it. The data, in this case, is from past year’s stock performance with the fields date, open, high, low, close, volume, and name, all of which describe characteristics of daily popular stocks. However, it is important to note that you can use any CSV file here to illustrate importing data.</p>
<h4 id="dataframe-head-function">Dataframe head function</h4>
<p>Showing the first few rows of your data is important to check to see if you have imported the correct CSV, as well as seeing if data looks good in general. The way to do this method is by calling your dataframe and attaching the <code>.head()</code> method to the end of it. This function will return the first 5 rows of your data by default. If you want to show more, you can put that value in the parentheses of <code>.head()</code>.</p>
<pre><code class="lang-python">import pandas as pd
</code></pre>
<pre><code class="lang-python">stocks_df = pd.read.csv(&#39;/documents/data/stock_data.csv&#39;)
</code></pre>
<pre><code class="lang-python">stocks_df.head()
</code></pre>
<p><center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1617986452/Screen_Shot_2021-04-09_at_12.40.35_PM_jtlhgz.png" /></center><br></p>
<h4 id="visualize-column-with-the-plot-function">Visualize column with the plot function</h4>
<p>The <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.plot.html">.plot()</a> method  is useful for displaying your dataframe’s columns. In this example, I am showing the x-axis as the “date” column, and the “close” column amount as the y-axis, visualized by a line chart.</p>
<pre><code class="lang-python">stocks_df.plot(x=&quot;date&quot;, y=&quot;close&quot;)
</code></pre>
<pre><code>&lt;AxesSubplot:xlabel=&#39;date&#39;&gt;
</code></pre><p><center><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1617986452/Screen_Shot_2021-04-09_at_12.40.20_PM_zkb0am.png" /></center><br></p>
<h3 id="4-suggestions-for-practical-applications-">4. Suggestions for practical applications:</h3>
<p>This overview of Python for data science has only just scratched the surface. There are plenty of practical applications that you can employ with Python in data science across several industries, including customer churn, sales forecasting, image classification, product classification, sentiment analysis, credit card fraud detection, and recommendation systems. DataCamp’s <a href="https://www.datacamp.com/community/tutorials/recommender-systems-python">Beginner Tutorial: Recommender Systems in Python</a> demonstrates how to successfully recommend movies to people based on a variety of factors with the use of machine learning. Another popular data science use case in the financial industry is credit card fraud detection, which is explained in <a href="https://www.datacamp.com/community/news/credit-card-fraud-detection-using-machine-learning-algorithm-8dyh3fefvrb">Credit Card Fraud Detection Using Machine Learning Algorithm</a>. As you can see, not only are there plenty of specific data science use cases, but there are also industry specific use cases.</p>
<p>For a more in-depth introduction to Python, check out DataCamp’s <a href="https://www.datacamp.com/courses/intro-to-python-for-data-science">Introduction to Python</a> course, or find out more about <a href="https://www.datacamp.com/community/blog/how-to-learn-python">learning Python on our blog</a>.</p>


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

Get a step-by-step guide on how to install Python and use it for basic data science functions.

Python Tutorial for Beginners | DataCamp

Python Tutorial for Beginners

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

Are you ready to begin your pandas journey? Here’s a step-by-step guide on how to get started.

pandas Tutorial for Beginners

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

Are you ready to begin your SQL journey? Here’s a step-by-step guide on how to get started.

SQL Tutorial for Beginners | DataCamp

SQL Tutorial for Beginners

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

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

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

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

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

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

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

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

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

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

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

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

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


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

(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

community

datacamp

Tutorials