Data Science Episodes

Data Science Articles

Data Science Tutorials

Data Science Cheat Sheets

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

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

Python For Data Science - A Cheat Sheet For Beginners

In this cheat sheet, you'll have a guide around the top machine learning algorithms, their advantages and disadvantages, and use-cases. 

Machine Learning Cheat Sheet

<p>SQL, also known as Structured Query Language, is a powerful tool to search through large amounts of data and return specific information for analysis. Learning SQL is crucial for anyone aspiring to be a data analyst, data engineer, or data scientist, and helpful in many other fields such as web development or marketing.</p>
<p>In this cheat sheet, you'll find a handy list of functions covering querying data, filtering data, aggregation, and more&mdash;all collected from our <a href="https://www.datacamp.com/tracks/sql-fundamentals">SQL Fundamentals Skill Track</a>.</p>
<p><a href="https://s3.amazonaws.com/assets.datacamp.com/email/other/SQL+for+Data+Science.pdf"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/v1649681885/download_d2f88d7c8d.png" alt="" /></a></p>
<h2 style="text-align: left;">The Different Dialects of SQL</h2>
<p>Although SQL languages all share a basic structure, some of the specific commands and styles can differ slightly. Popular dialects include MySQL, SQLite, SQL Server, Oracle SQL, and more. PostgreSQL is a good place to start &mdash;since it&rsquo;s close to standard SQL syntax and is easily adapted to other dialects.&nbsp;</p>
<h2 style="text-align: left;">Sample Data</h2>
<p>Throughout this cheat sheet, we'll be using the sample data <code>airbnb_listings</code>&mdash;denoting rental apartments on Airbnb.</p>
<table style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif; width: 99.992%; height: 89.6024px;" border="1"><colgroup><col style="width: 19.9687%;" /><col style="width: 19.9687%;" /><col style="width: 19.9687%;" /><col style="width: 19.9687%;" /><col style="width: 19.9687%;" /></colgroup>
<tbody>
<tr style="height: 22.4006px;">
<td style="height: 22.4006px;"><strong>id</strong></td>
<td style="height: 22.4006px;"><strong>city</strong></td>
<td style="height: 22.4006px;"><strong>country</strong></td>
<td style="height: 22.4006px;"><strong>number_of_rooms</strong></td>
<td style="height: 22.4006px;"><strong>year_listed</strong></td>
</tr>
<tr style="height: 22.4006px;">
<td style="height: 22.4006px;">1</td>
<td style="height: 22.4006px;">Paris</td>
<td style="height: 22.4006px;">France</td>
<td style="height: 22.4006px;">5</td>
<td style="height: 22.4006px;">2018</td>
</tr>
<tr style="height: 22.4006px;">
<td style="height: 22.4006px;">2</td>
<td style="height: 22.4006px;">Tokyo</td>
<td style="height: 22.4006px;">Japan</td>
<td style="height: 22.4006px;">2</td>
<td style="height: 22.4006px;">2017</td>
</tr>
<tr style="height: 22.4006px;">
<td style="height: 22.4006px;">3</td>
<td style="height: 22.4006px;">New York</td>
<td style="height: 22.4006px;">USA</td>
<td style="height: 22.4006px;">2</td>
<td style="height: 22.4006px;">2022</td>
</tr>
</tbody>
</table>
<h2 style="text-align: left;">Querying tables</h2>
<h3>Get all the columns from a table</h3>
<pre class="language-sql"><code>SELECT * 
FROM airbnb_listings;</code></pre>
<h3>Return the <code>city</code> column from the table</h3>
<pre class="language-sql"><code>SELECT city 
FROM airbnb_listings;</code></pre>
<h3>Get the <code>city</code> and <code>year_listed</code> columns from the table</h3>
<pre class="language-sql"><code>SELECT city, year_listed
FROM airbnb_listings;
</code></pre>
<h3>Get the listing <code>id</code>, <code>city</code>, ordered by the <code>number_of_rooms</code> in ascending order</h3>
<pre class="language-sql"><code>SELECT city, year_listed 
FROM airbnb_listings 
ORDER BY number_of_rooms ASC;
</code></pre>
<h3>Get the listing <code>id</code>, <code>city</code>, ordered by the <code>number_of_rooms</code> in descending order</h3>
<pre class="language-sql"><code>SELECT city, year_listed 
FROM airbnb_listings 
ORDER BY number_of_rooms DESC;
</code></pre>
<h3>Get the first 5 rows from <code>airbnb_listings</code></h3>
<pre class="language-sql"><code>SELECT * 
FROM airbnb_lisitings
LIMIT 5;
</code></pre>
<h3>Get a unique list of cities where there are listings</h3>
<pre class="language-sql"><code>SELECT DISTINCT city
FROM airbnb_lisitings;
</code></pre>
<h2 style="text-align: left;">Filtering on numeric columns</h2>
<h3>Get all the listings where <code>number_of_rooms</code> is more or equal to 3</h3>
<pre class="language-sql"><code>SELECT *
FROM airbnb_listings 
WHERE number_of_rooms &gt;= 3;</code></pre>
<h3>Get all the listings where <code>number_of_rooms</code> is more than 3</h3>
<pre class="language-sql"><code>SELECT *
FROM airbnb_listings 
WHERE number_of_rooms &gt; 3;</code></pre>
<h3>Get all the listings where <code>number_of_rooms</code> is exactly 3</h3>
<pre class="language-sql"><code>SELECT *
FROM airbnb_listings 
WHERE number_of_rooms = 3;</code></pre>
<h3>Get all the listings where <code>number_of_rooms</code> is&nbsp;lower or equal to 3</h3>
<pre class="language-sql"><code>SELECT *
FROM airbnb_listings 
WHERE number_of_rooms &lt;= 3;</code></pre>
<h3>Get all the listings where <code>number_of_rooms</code> is lower than 3</h3>
<pre class="language-sql"><code>SELECT *
FROM airbnb_listings 
WHERE number_of_rooms &lt; 3;</code></pre>
<h3>Filtering columns within a range&mdash;Get all the listings with 3 to 6 rooms</h3>
<pre class="language-sql"><code>SELECT *
FROM airbnb_listings 
WHERE number_of_rooms BETWEEN 3 AND 6;</code></pre>
<h2 style="text-align: left;">Filtering on text columns</h2>
<h3>Get all the listings that are based in <code>'Paris'</code></h3>
<pre class="language-sql"><code>SELECT * 
FROM airbnb_listings 
WHERE city = &rsquo;Paris&rsquo;;
</code></pre>
<h3><strong>Filter one column on many conditions&mdash;Get the listings based in the <code>'USA'</code> and in <code>&lsquo;France&rsquo;</code></strong></h3>
<pre class="language-sql"><code>SELECT *
FROM airbnb_listings 
WHERE country IN (&lsquo;USA&rsquo;, &lsquo;France&rsquo;);</code></pre>
<h3>Get all listings where <code>city</code> starts with <code>"j"</code> and where it does not end with <code>"t"</code></h3>
<pre class="language-sql"><code>SELECT * 
FROM airbnb_listings 
WHERE city LIKE &lsquo;j%&rsquo; AND city NOT LIKE &lsquo;%t&rsquo;;
</code></pre>
<h2 style="text-align: left;">Filtering on multiple columns</h2>
<h3>Get all the listings in <code>"Paris"</code> where <code>number_of_rooms</code> is bigger than 3</h3>
<pre class="language-sql"><code>SELECT *
FROM airbnb_listings 
WHERE city = &rsquo;Paris&rsquo; AND number_of_rooms &gt; 3;
</code></pre>
<h3>Get all the listings in <code>"Paris"</code> OR the ones that were listed after 2012</h3>
<pre class="language-sql"><code>SELECT * 
FROM airbnb_listings
WHERE city = 'Paris' OR year_listed &gt; 2012;</code></pre>
<h2 style="text-align: left;">Filtering on missing data</h2>
<h3>Get all the listings where <code>number_of_rooms</code> is missing</h3>
<pre class="language-sql"><code>SELECT *
FROM airbnb_listings 
WHERE number_of_rooms IS NULL; 
</code></pre>
<h3>Get all the listings where <code>number_of_rooms</code> is not missing</h3>
<pre class="language-sql"><code>SELECT *
FROM airbnb_listings 
WHERE number_of_rooms IS NOT NULL; 
</code></pre>
<h2 style="text-align: left;">Simple aggregations</h2>
<h3>Get the total number of rooms available across all listings&nbsp;</h3>
<pre class="language-sql"><code>SELECT SUM(number_of_rooms) 
FROM airbnb_listings; </code></pre>
<h3><strong>Get the average number of rooms per listing across all listings</strong></h3>
<pre class="language-sql"><code>SELECT AVG(number_of_rooms) 
FROM airbnb_listings;
</code></pre>
<h3>Get the listing with the highest number of rooms across all listings</h3>
<pre class="language-sql"><code>SELECT MAX(number_of_rooms) 
FROM airbnb_listings;</code></pre>
<h3><strong>Get the listing with the lowest number of rooms across all listings</strong><span style="font-weight: 400;"><br /></span></h3>
<pre class="language-sql"><code>SELECT MIN(number_of_rooms) 
FROM airbnb_listings;
</code></pre>
<h2 style="text-align: left;">Grouping, filtering, and sorting&nbsp;</h2>
<h3>Get the total number of rooms for each country</h3>
<pre class="language-sql"><code>SELECT country, SUM(number_of_rooms)
FROM airbnb_listings
GROUP BY country;</code></pre>
<h3>Get the average number of rooms for each country</h3>
<pre class="language-sql"><code>SELECT country, AVERAGE(number_of_rooms)
FROM airbnb_listings
GROUP BY country;</code></pre>
<h3>Get the listing with the maximum number of rooms for each country</h3>
<pre class="language-sql"><code>SELECT country, MAX(number_of_rooms)
FROM airbnb_listings
GROUP BY country;</code></pre>
<h3>Get the listing with the lowest amount of rooms per country</h3>
<pre class="language-sql"><code>SELECT country, MIN(number_of_rooms)
FROM airbnb_listings
GROUP BY country;</code></pre>
<h3>For each country, get the average number of rooms per listing, sorted by ascending order</h3>
<pre class="language-sql"><code>SELECT country, AVG(number_of_rooms) AS avg_rooms
FROM airbnb_listings
GROUP BY country
ORDER BY avg_rooms ASC;</code></pre>
<h3>&nbsp;</h3>
<h3>For Japan and the USA, get the average number of rooms per listing in each country</h3>
<pre class="language-sql"><code>SELECT country, MAX(number_of_rooms)
FROM airbnb_listings
WHERE country IN (&lsquo;USA&rsquo;, &lsquo;Japan&rsquo;);
GROUP BY country;</code></pre>
<h3>Get the number of cities per country, where there are listings</h3>
<pre class="language-sql"><code>SELECT country, COUNT(city) AS number_of_cities
FROM airbnb_listings
GROUP BY country;</code></pre>
<h3>Get all the years where there were more than 100 listings per year</h3>
<pre class="language-sql"><code>SELECT year_listed
FROM airbnb_listings
GROUP BY year_listed
HAVING COUNT(id) &gt; 100;</code></pre>

With this SQL cheat sheet, you'll have a handy reference guide to basic querying tables, filtering data, and aggregating data

SQL Basics Cheat Sheet

<p>The tidyverse is a powerful collection of R packages that you can use for data science. They are designed to help you to transform and visualize data. All packages within this collection share an underlying philosophy and common APIs.</p>
<p>As you might know, DataCamp recently launched the <a href="https://www.datacamp.com/courses/introduction-to-the-tidyverse">Introduction to the Tidyverse</a> course together with David Robinson, Data Scientist at Stack Overflow.</p>
<p>Now, DataCamp has created a tidyverse cheat sheet for beginners that have already taken the course and that still want a handy one-page reference or for those who need an extra push to get started on discovering this popular collection of packages. You must have already run into packages such as <code>ggplot2</code> and <code>dplyr</code>, so this cheat sheet will definitely come in handy!</p>
<p>It's a quick guide through the basics of manipulating and visualizing your data the powerful tools that the tidyverse has to offer in R!</p>
<p><a href="http://datacamp-community-prod.s3.amazonaws.com/c1fae72f-d2d7-4646-9dce-dd0f8fb5c5e8"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1625839345/Tidyverse_Cheat_Sheet_For_Beginners_d4lkxp.png" /></a></p>
<p>The tidyverse cheat sheet will guide you through some general information on the tidyverse, and then covers topics such as useful functions, loading in your data, manipulating it with <code>dplyr</code> and lastly, visualize it with <code>ggplot2</code>.</p>
<p>In short, everything that you need to kickstart your data science learning with R!</p>
<p>Do you want to learn more? Also check out and star the <a href="https://www.datacamp.com/courses/exploratory-data-analysis-in-r-case-study">Exploratory Data Analysis in R: Case Study</a> course, also taught by David Robinson, for free now!</p>
<p>Also, don't miss out on our <a href="https://www.datacamp.com/community/tutorials/data-table-cheat-sheet">data.table cheat sheet</a> for data manipulation in R and our <a href="https://www.datacamp.com/community/data-science-cheatsheets">other cheat sheets for data science</a>.</p>
<p>&nbsp;</p>
<h2>What is Tidyverse?&nbsp;&nbsp;</h2>
<p>The tidyverse is a powerful collection&nbsp; of&nbsp; R&nbsp; packages&nbsp; that are actually&nbsp; data tools for transforming and visualizing data. All packages of the tidyverse share an underlying philosophy and common APls.</p>
<p>The core packages are:&nbsp;</p>
<ul>
<li>ggplot2, which implements the grammar of graphics. Y<span style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;">ou can </span><span style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;">use it </span><span style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;">to visualize your data.</span></li>
<li><span style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;">dplyr is </span><span style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;">a grammar of data You can </span><span style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;">use it to </span><span style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;">solve the </span><span style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;">most </span><span style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;">common data </span><span style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;">manipulation </span><span style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;">challenges.</span></li>
<li>tidyr helps you to create tidy data or data where each variable is in a column, each observation is a row end each value is a column, each observation is a row end each value is a cell.&nbsp;</li>
<li>readr is a fast and friendly way to read rectangular</li>
<li>purrr enhances R"s functional programming (FP)toolkit by providing a complete and consistent set of tools for working with functions and vectors.&nbsp;</li>
<li>tibble is a modern re-imaginging of the data</li>
<li>stringr provides a cohesive set of functions designed to make working with strings as easy as possible</li>
<li>forcats provide a suite of useful&nbsp; tools that solve common problems with factors.&nbsp;&nbsp;</li>
</ul>
<p><strong>You can install the complete tidyverse with:</strong></p>
<p>&gt; install.packages("tidyverse")</p>
<p><strong>Then, load the core tidyverse and make it available in your current R session by running:</strong></p>
<p>&gt; library(tidyverse)</p>
<p>Note: there are many other tidyverse packages with more specialised usage. They are not &nbsp;loaded automatically with</p>
<p>library(tidyverse),so you'll need to load each one with its own call to library().</p>
<h2><strong>Useful Functions </strong></h2>
<pre class="language-r"><code>&gt; tidyverse_conflicts() #Conflicts between tidyverse and other packages
&gt; tidyverse_deps() #List all tidyverse dependencies
&gt; tidyverse_logo() #Get tidyverse logo, using ASCII or unicode characters
&gt; tidyverse_packages() #List all tidyverse packages
&gt; tidyverse_update() #Update tidyverse packages
</code></pre>
<h2><strong>Loading in the Data&nbsp;</strong></h2>
<pre class="language-r"><code>&gt;	library(datasets) #Load the datasets package
&gt;	library(gapminder) #Load the gapminder package
&gt;	attach(iris) #Attach iris data to the R search path
</code></pre>
<h2><strong>Dplyr&nbsp;</strong></h2>
<h3><strong>Filter&nbsp;</strong></h3>
<p><strong>filter() </strong><strong>allows you </strong><strong>to select </strong><strong>a </strong><strong>subset of rows in </strong><strong>a </strong><strong>data frame.</strong></p>
<pre class="language-r"><code>&gt;iris%&gt;% #Select iris data of species "virginica"
          filter(Species=1"virginica")

&gt;iris%&gt;% #Select iris data of species "virginica" and sepal length greater than 6. 
           filter(Species="virginica",
           Sepal.Length&gt; 6)</code></pre>
<h3><strong>Arrange&nbsp;</strong></h3>
<p><strong>arrange() sorts the observations in a dataset in ascending or descending order based on one of its variables.</strong></p>
<pre class="language-r"><code>&gt;iris%&gt;% #Sort in ascending order of sepal length
          arrange(Sepal.Length)
&gt;iris%&gt;% #Sort in descending order of sepal length
          arrange(desc(Sepal.Length))</code></pre>
<p><strong>Combine multiple dplyr verbs in a row with the pipe operator </strong>%&gt;%:</p>
<pre class="language-r"><code>&gt;iris%&gt;% #Filter for species "virginica" then arrange in descending order of sepal length
          filter(Species="virginica") %&gt;% 
          arrange(desc(Sepal.Length))</code></pre>
<h3><strong>Mutate&nbsp;</strong></h3>
<p><strong>mutate() allows you to update or create new columns of a data frame.</strong></p>
<pre class="language-r"><code>&gt;iris%&gt;% #Change Sepal.Length to be in millimeters
     mutate(Sepal.Length=Sepal.Length*10)
&gt;iris%&gt;% #Create a new column called SLMm
     mutate(SLMm=Sepal.Length*10)</code></pre>
<p><strong>Combine the verbs filter(), arrange(), and mutate():</strong></p>
<pre class="language-r"><code>&gt;iris%&gt;%
     filter(Species="Virginica") %&gt;% 
     mutate(SLMm=Sepal.Length*10) %&gt;% 
     arrange(desc(SLMm))</code></pre>
<h3><strong>Summarize&nbsp;</strong></h3>
<p><strong>summarize() allows you to turn many observations into a </strong><strong>single </strong><strong>data point.</strong></p>
<pre class="language-r"><code>&gt;iris%&gt;% #Summarize to find the median sepal length 
     summarize(medianSL=median(Sepal.Length))

&gt;iris%&gt;% #Filter for virginica then summarize the median sepal Length
     filter(Species="virginica") %&gt;% 
     summarize(medianSL=median(Sepal.Length))</code></pre>
<p><strong>You can also summarize multiple variables at once:</strong></p>
<pre class="language-r"><code>&gt;iris%&gt;%
     filter(Species="virginica") %&gt;% 
     summarize(medianSL=median(Sepal.Length),
          maxSL=max(Sepal.Length))</code></pre>
<p><strong>group_by</strong><strong> </strong><strong>()</strong><strong> </strong><strong>allows</strong><strong> </strong><strong>you</strong><strong> </strong><strong>to</strong><strong> </strong><strong>summarize</strong><strong> </strong><strong>within groups</strong><strong> </strong><strong>instead</strong><strong> </strong><strong>of summarizing the entire dataset:</strong></p>
<pre class="language-r"><code>&gt;iris%&gt;% #Find median and max sepal length of each species 
     group_by(Species) %&gt;% 
     summarize(medianSL=median(Sepal.Length), 
     maxSL=max(Sepal.Length))

&gt;iris%&gt;% #Find median and max petal length of each species with sepal length&gt; 6 
     filter(Sepal.Length&gt;6) %&gt;%
     group_by(Species) %&gt;% 
     summarize(medianPL=median(Petal.Length), 
     maxPL=max(Petal.Length))</code></pre>
<h2><strong>ggplot2</strong></h2>
<h3><strong>Scatter Plot&nbsp;</strong></h3>
<p><strong>Scatter plots allow you to compare two variables within your data. To do this with ggplot2, you use geom_point()</strong></p>
<pre class="language-r"><code>&gt;iris_small f- iris%&gt;%
     filter(Sepal.Length &gt; 5)

&gt;ggplot(iris_small, aes(x=Petal.Length, #Compare petal width and length
     y=Petal.Width)) + geom_point()</code></pre>
<h3><strong>Additional Aesthetics </strong></h3>
<p><strong>Color</strong></p>
<div>
<p><img src="https://res.cloudinary.com/dyd911kmh/image/upload/v1652350288/Color_1_981312dad3.png" alt="" /></p>
</div>
<pre class="language-r"><code>&gt;ggplot(iris_small, aes(x=Petal.Length, 
     y=Petal.Width,
     calar=Species)) + 
  geom_point()</code></pre>
<p><strong>Size</strong></p>
<p><img src="https://res.cloudinary.com/dyd911kmh/image/upload/v1652350288/Size_1_6f5efb4ee5.png" alt="" /></p>
<pre class="language-r"><code>&gt;ggplot(iris_small, aes(x=Petal.Length,
          y=Petal.Width, 
          color=Species, 
          size=Sepal.Length)) +
     geom_point()</code></pre>
<p><strong>Faceting</strong></p>
<p><img src="https://res.cloudinary.com/dyd911kmh/image/upload/v1652350406/Faceting_1_00cf2d1613.png" alt="" /></p>
<pre class="language-r"><code>&gt;ggplot(iris_small, aes(x=Petal.Length,
          y=Petal.Width)) +
     geom_point()+ 
     facet_wrap(NSpecies)</code></pre>
<h3><strong>&nbsp;Line Plots&nbsp;</strong></h3>
<p><img src="https://res.cloudinary.com/dyd911kmh/image/upload/v1652350407/Line_Plots_1_78fc05a798.png" alt="" /></p>
<pre class="language-r"><code>&gt;	by_year &lt;-- gapminder %&gt;% 
          group_by(year) %&gt;%
          summarize(medianGdpPerCap=median(gdpPercap))
&gt;	ggplot(by_year, aes(x=year,
          y=medianGdpPerCap))+
     geom_line()+ 
     expand_limits(y=0)
</code></pre>
<h3>Bar Plots&nbsp;</h3>
<p><img src="https://res.cloudinary.com/dyd911kmh/image/upload/v1652350406/bar_plots_1_86e583e6fc.png" alt="" /></p>
<pre class="language-r"><code>&gt; by_species &lt;--iris%&gt;% 
     filter(Sepal.Length&gt;6) %&gt;% 
     group_by(Species) %&gt;% 
     summarize(medianPL=median(Petal.Length))
&gt; ggplot(by_species, aes(x=Species,
          y=medianPL)) +
     geom_col()</code></pre>
<h3>Histograms&nbsp;</h3>
<p><img src="https://res.cloudinary.com/dyd911kmh/image/upload/v1652350407/Histograms_1_c4c4ff2be8.png" alt="" /></p>
<pre class="language-r"><code>&gt; ggplot(iris_small, aes(x=Petal.Length))+ 
     geom_histogram()</code></pre>
<h3>Box Plots&nbsp;</h3>
<p><img src="https://res.cloudinary.com/dyd911kmh/image/upload/v1652350406/Box_plots_1_2fc6d4c0b7.png" alt="" /></p>
<pre class="language-r"><code>&gt; ggplot(iris_small, aes(x=Species,
          y=Sepal.Width))+
     geom_boxplot()
</code></pre>
<p><strong>(Click above to download a printable version or read the online version below)</strong>.</p>
<h2>Learn more about Tidyverse</h2>
<p>Here are a few extra Tidyverse resources to get you started:</p>
<p class="css-9jzl91-CourseShowPage" data-cy="course-title"><a href="https://www.datacamp.com/courses/introduction-to-the-tidyverse">Introduction to the Tidyverse</a></p>
<p class="css-9jzl91-CourseShowPage" data-cy="course-title"><a href="https://www.datacamp.com/courses/working-with-data-in-the-tidyverse">Working with Data in the Tidyverse</a></p>
<p class="css-9jzl91-CourseShowPage" data-cy="course-title"><a href="https://www.datacamp.com/courses/network-analysis-in-the-tidyverse">Network Analysis in the Tidyverse</a></p>
<p class="css-9jzl91-CourseShowPage" data-cy="course-title"><a href="https://www.datacamp.com/courses/machine-learning-in-the-tidyverse">Machine Learning in the Tidyverse</a></p>

This tidyverse cheat sheet will guide you through the basics of the tidyverse, and 2 of its core packages: dplyr and ggplot2! 

Tidyverse Cheat Sheet For Beginners

<p>You most probably will know by now that data storytelling, accomplished by data visualization, amongst other things, is an essential skill for every data scientist: after you have turned the raw data into understanding, insights and knowledge, you also need to communicate these findings effectively to your audience.</p>
<p>For most beginners, the first Python data visualization library that they use is, naturally, Matplotlib. It is a Python 2D plotting library that enables users to make publication-quality figures. It is quite an extensive library where a <a href="https://www.datacamp.com/community/blog/python-matplotlib-cheat-sheet">cheat sheet</a> will definitely come in handy when you're learning, but when you manage to use this library effectively, you'll also be able to get insights and work better with other packages, such as Pandas, that intend to build more plotting integration with Matplotlib as time goes on.</p>
<p>Another package that you'll be able to tackle easily is Seaborn, the statistical data visualization library of Python.</p>
<p>DataCamp has created a Seaborn cheat sheet for those who are ready to get started with this data visualization library with the help of a handy one-page reference.</p>
<p>You'll see that this cheat sheet presents you with the five basic steps that you can go through to make beautiful statistical graphs in Python.</p>
<p>Check out the infographic by clicking on the button below:</p>
<p><a href="http://datacamp-community-prod.s3.amazonaws.com/263130e2-2c92-4348-a356-9ed9b5034247"><img style="width: 800px; height: 419px;" src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1625839419/Python_Seaborn_Cheat_Sheet_q074wv.png" alt="Seaborn Python cheat sheet" /></a></p>
<p>This cheat sheet will walk you through the five steps that you need to go through to make these plots: you'll see how you can load in data, set the figure aesthetics, plot, customize and eventually, show or save your plot with Seaborn.</p>
<p>What might have looked difficult before will definitely be more clear once you start using this cheat sheet! Use it in combination with the <a href="http://seaborn.pydata.org/examples/index.html">Seaborn Gallery</a>, the <a href="http://seaborn.pydata.org/index.html">documentation</a>, and our <a href="https://www.datacamp.com/community/tutorials/seaborn-python-tutorial">Seaborn tutorial</a>.</p>
<p>Also, don't miss out on our other cheat sheets for data science that cover <a href="https://www.datacamp.com/community/blog/python-scipy-cheat-sheet/">SciPy</a>, <a href="https://www.datacamp.com/community/blog/python-numpy-cheat-sheet/">NumPy</a>, <a href="https://www.datacamp.com/community/blog/scikit-learn-cheat-sheet/">Scikit-Learn</a>, <a href="https://www.datacamp.com/community/blog/bokeh-cheat-sheet-python/">Bokeh</a>, <a href="https://www.datacamp.com/community/blog/python-pandas-cheat-sheet/">Pandas</a> and the <a href="https://www.datacamp.com/community/tutorials/python-data-science-cheat-sheet-basics/">Python basics</a>.</p>
<h2>Learn more about Seaborn</h2>
<p><a href="datacamp.com/courses/introduction-to-data-visualization-with-seaborn">Introduction to Data Visualization with Seaborn</a></p>
<p><a href="https://datacamp.com/courses/intermediate-data-visualization-with-seaborn">Intermediate Data Visualization with Seaborn</a><br /><br /></p>

This Python Seaborn cheat sheet with code samples guides you through the data visualization library that is based on Matplotlib.

Python Seaborn Cheat Sheet

<p>By now, you will have already learned that NumPy, one of the fundamental packages for scientific computing, forms at least for a part&nbsp;the fundament of other important&nbsp;packages that you might use used for data manipulation and machine learning with Python. One of those packages is SciPy, another one&nbsp;of the core packages for scientific computing in Python that provides mathematical algorithms and convenience functions built on the&nbsp;NumPy extension of Python.&nbsp;</p>
<p>You might now wonder why this library might come in handy for data science.&nbsp;</p>
<p>Well, SciPy has many modules that will help you to understand some of the basic components that you need to master when you're learning data science, namely, math, stats and machine learning. You can find out what other things you need to tackle to learn data science <a href="https://www.datacamp.com/community/tutorials/learn-data-science-infographic/">here</a>. You'll see that for statistics, for example, a module like&nbsp;scipy.stats, etc. will definitely be of interest to you.</p>
<p>The other topic that was mentioned was machine learning: here, the&nbsp;scipy.linalg&nbsp;and scipy.sparse modules will offer everything that you're looking for to understand machine learning concepts such as eigenvalues, regression, and matrix multiplication...</p>
<p>But, what is maybe the most obvious is that most machine learning techniques deal with high-dimensional data and that data is often represented as matrices. What's more, you'll need to understand how to manipulate these matrices. &nbsp;</p>
<p>That is why DataCamp has made a SciPy cheat sheet that will help you to master linear algebra with Python.&nbsp;</p>
<p>Take a look by clicking on the button below:</p>
<p><a href="http://datacamp-community-prod.s3.amazonaws.com/dfdb6d58-e044-4b38-bab3-5de0b825909b"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1625838166/SciPy_Cheat_Sheet-_Linear_Algebra_in_Python_ff0oa8.png" alt="python scipy cheat sheet" /></a></p>
<p>&nbsp;</p>
<p>You'll see that this SciPy cheat sheet covers the basics of linear algebra&nbsp;that you need to get started: it provides a brief explanation of what the&nbsp;library has to offer and how you can use it to interact with NumPy, and goes on to summarize topics in linear algebra, such as matrix creation, matrix functions,&nbsp;basic routines that you can perform with matrices, and matrix decompositions from scipy.linalg. Sparse matrices are also included, with their own routines, functions, and decompositions from the scipy.sparse module.&nbsp;</p>
<p>(Above is the printable version of this cheat sheet)</p>
<div id="scoped-content">
<h2>Python for Data-Science Cheat Sheet: SciPy - Linear Algebra</h2>
<h2>SciPy</h2>
<p>The SciPy library is one of the core packages for scientific computing that provides mathematical algorithms and convenience functions built on the NumPy extension of Python.</p>
<h2>Asking For Help</h2>
<pre class="language-python"><code>help(scipy.linalg.diagsvd)</code></pre>
<h2>Interacting With NumPy</h2>
<table>
<tbody>
<tr>
<td>
<pre class="language-python"><code>import numpy as np</code></pre>
</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>a : np.array([1,2,3])</code></pre>
</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>b : np.array([(1+5j,2j,3j), (4j,5j,6j)])</code></pre>
</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>c : np.array([[(1.5,2,3), (4,5,6)], [(3,2,1), (4,5,6)]])</code></pre>
</td>
</tr>
</tbody>
</table>
<h3>Index Tricks</h3>
<table>
<tbody>
<tr>
<td>
<pre class="language-python"><code>np.mgrid[0:5,0:5]</code></pre>
</td>
<td>Create a dense meshgrid</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.ogrid[0:2,0:2]</code></pre>
</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.r_[3,[0]*5,-1:1:10j]</code></pre>
</td>
<td>Stack arrays vertically (row-wise)</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.c_[b,c]</code></pre>
</td>
</tr>
</tbody>
</table>
<h3>Shape Manipulation</h3>
<table>
<tbody>
<tr>
<td>
<pre class="language-python"><code>np.transpose(b)</code></pre>
</td>
<td>Permute array dimensions</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>b.flatten()</code></pre>
</td>
<td>Flatten the array</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.hstack((b,c))</code></pre>
</td>
<td>Stack arrays horizontally (column-wise)</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.vstack((a,b))</code></pre>
</td>
<td>Stack arrays vertically (row-wise)</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.hsplit(c,2)</code></pre>
</td>
<td>Split the array horizontally at the 2nd index</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.vpslit(d,2)</code></pre>
</td>
</tr>
</tbody>
</table>
<h3>Polynomials</h3>
<table>
<tbody>
<tr>
<td>
<pre class="language-python"><code>from numpy import poly1d</code></pre>
</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>p : poly1d([3,4,5])</code></pre>
</td>
<td>Create a polynomial object</td>
</tr>
</tbody>
</table>
<h3>Vectorizing Functions</h3>
<table>
<tbody>
<tr>
<td>
<pre class="language-python"><code>def myfunc(a):&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;
   if a &lsaquo; 0:  
      return a*2&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;
   else:&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;
      return a/2</code></pre>
</td>
<td>&nbsp;</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.vectorize(myfunc)</code></pre>
</td>
<td>Vectorize functions</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.real(b)</code></pre>
</td>
<td>Return the real part of the array elements</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.imag(b)</code></pre>
</td>
<td>Return the imaginary part of the array elements</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.real_if_close(c,tol:1000)</code></pre>
</td>
<td>Return a real array if complex parts close to 0</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.cast['f'](np.pi)</code></pre>
</td>
<td>Cast object to a data type</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.angle(b,deg:True)</code></pre>
</td>
<td>Return the angle of the complex argument</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>g : np.linspace(0,np.pi,num:5)</code></pre>
</td>
<td>Create an array of evenly spaced values (number of samples)</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>g [3:] +: np.pi</code></pre>
</td>
<td>&nbsp;</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.unwrap(g)</code></pre>
</td>
<td>&nbsp;</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.logspace(0,10,3)</code></pre>
</td>
<td>Create an array of evenly spaced values (log scale)</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.select([c&lt;4],[c*2])</code></pre>
</td>
<td>Return values from a list of arrays depending on conditions</td>
</tr>
<tr>
<td>
<pre class="language-markup"><code>misc.factorial(a)</code></pre>
</td>
<td>Factorial</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>misc.comb(10,3,exact:True)</code></pre>
</td>
<td>Combine N things taken at k time</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>misc.central_diff_weights(3)</code></pre>
</td>
<td>Weights for Np-point central derivative</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>misc.derivative(myfunc,1.0)</code></pre>
</td>
<td>Find the n-th derivative of a function at a point</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>from scipy import linalg, sparse</code></pre>
</td>
<td>&nbsp;</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>A : np.matrix(np.random.random((2,2)))</code></pre>
</td>
<td>&nbsp;</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>B : np.asmatrix(b)</code></pre>
</td>
<td>&nbsp;</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>C : np.mat(np.random.random((10,5)))</code></pre>
</td>
<td>&nbsp;</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>D : np.mat([[3,4], [5,6]])</code></pre>
<p>&nbsp;</p>
</td>
<td>&nbsp;</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>A.I</code></pre>
</td>
<td>Inverse</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.inv(A)</code></pre>
</td>
<td>Inverse</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>A.T</code></pre>
</td>
<td>Tranpose matrix</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>A.H</code></pre>
</td>
<td>Conjugate transposition</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.trace(A)</code></pre>
</td>
<td>Trace</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.norm(A)</code></pre>
</td>
<td>Frobenius norm</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.norm(A,1)</code></pre>
</td>
<td>L1 norm (max column sum)</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.norm(A,np.inf)</code></pre>
</td>
<td>L inf norm (max row sum)</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.linalg.matrix_rank(C)</code></pre>
</td>
<td>Matrix rank</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.det(A)</code></pre>
</td>
<td>Determinant</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.solve(A,b)</code></pre>
</td>
<td>Solver for dense matrices</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>E : np.mat(a).T</code></pre>
</td>
<td>Solver for dense matrices</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.lstsq(F,E)</code></pre>
</td>
<td>Least-squares solution to linear matrix equation</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.pinv(C)</code></pre>
</td>
<td>Compute the pseudo-inverse of a matrix (least-squares solver</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.pinv2(C)</code></pre>
</td>
<td>Compute the pseudo-inverse of a matrix (SVD)</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>F : np.eye(3, k:1)</code></pre>
</td>
<td>Create a 2X2 identity matrix</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>G : np.mat(np.identity(2))</code></pre>
</td>
<td>Create a 2x2 identity matrix</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>C[C &gt; 0.5] : 0</code></pre>
</td>
<td>&nbsp;</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>H : sparse.csr_matrix(C)</code></pre>
</td>
<td>Compressed Sparse Row matrix</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>I : sparse.csc_matrix(D)</code></pre>
</td>
<td>Compressed Sparse Column matrix</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>J : sparse.dok_matrix(A)</code></pre>
</td>
<td>Dictionary Of Keys matrix</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>E.todense()</code></pre>
</td>
<td>Sparse matrix to full matrix</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>sparse.isspmatrix_csc(A)</code></pre>
</td>
<td>Identify sparse matrix</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>sparse.linalg.inv(I)</code></pre>
</td>
<td>Inverse</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>sparse.linalg.norm(I)</code></pre>
</td>
<td>Norm</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>sparse.linalg.spsolve(H,I)</code></pre>
</td>
<td>Solver for sparse matrices</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>la, v : sparse.linalg.eigs(F,1)</code></pre>
</td>
<td>Eigenvalues and eigenvectors</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>sparse.linalg.svds(H, 2)</code></pre>
</td>
<td>SVD</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>sparse.linalg.expm(I)</code></pre>
</td>
<td>Sparse matrix exponential</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.add(A,D)</code></pre>
</td>
<td>Addition</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.subtract(A,D)</code></pre>
</td>
<td>Subtraction</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.divide(A,D)</code></pre>
</td>
<td>Division</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>A @ D</code></pre>
</td>
<td>Multiplication operator (Python 3)</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.multiply(D,A)</code></pre>
</td>
<td>Multiplication</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.dot(A,D)</code></pre>
</td>
<td>Dot product</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.vdot(A,D)</code></pre>
</td>
<td>Vector dot product</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.inner(A,D)</code></pre>
</td>
<td>Inner product</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.outer(A,D)</code></pre>
</td>
<td>Outer product</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.tensordot(A,D)</code></pre>
</td>
<td>Tensor dot product</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.kron(A,D)</code></pre>
</td>
<td>Kronecker product</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.expm(A)</code></pre>
</td>
<td>Matrix exponential</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.expm2(A)</code></pre>
</td>
<td>Matrix exponential (Taylor Series)</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.expm3(D)</code></pre>
</td>
<td>Matrix exponential (eigenvalue decomposition)</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.logm(A)</code></pre>
</td>
<td>Matrix logarithm</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.sinm(D)</code></pre>
</td>
<td>Matrix sine</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.cosm(D)</code></pre>
</td>
<td>Matrix cosine</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.tanm(A)</code></pre>
</td>
<td>Matrix tangent</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.sinhm(D)</code></pre>
</td>
<td>Hypberbolic matrix sine</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.coshm(D)</code></pre>
</td>
<td>Hyperbolic matrix cosine</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.tanhm(A)</code></pre>
</td>
<td>Hyperbolic matrix tangent</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.signm(A)</code></pre>
</td>
<td>Matrix sign function</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.sqrtm(A)</code></pre>
</td>
<td>Matrix square root</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.funm(A, lambda x: x*x)</code></pre>
</td>
<td>Evaluate matrix function</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>la, v : linalg.eig(A)</code></pre>
</td>
<td>Solve ordinary or generalized eigenvalue problem for square matrix</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>l1, l2 : la</code></pre>
</td>
<td>Unpack eigenvalues</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>v[:,0]</code></pre>
</td>
<td>First eigenvector</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>v[:,1]</code></pre>
</td>
<td>Second eigenvector</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>linalg.eigvals(A)</code></pre>
</td>
<td>Unpack eigenvalues</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>U,s,Vh : linalg.svd(B)</code></pre>
</td>
<td>Singular Value Decomposition (SVD)</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>M,N : B.shape</code></pre>
</td>
<td>&nbsp;</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>Sig : linalg.diagsvd(s,M,N)</code></pre>
</td>
<td>Construct sigma matrix in SVD</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>P,L,U : linalg.lu(C)</code></pre>
</td>
<td>LU Decomposition</td>
</tr>
<tr>
<td>
<pre class="language-python"><code>np.info(np.matrix)</code></pre>
</td>
<td>&nbsp;</td>
</tr>
</tbody>
</table>
</div>

This Python cheat sheet is a handy reference with code samples for doing linear algebra with SciPy and interacting with NumPy.

SciPy Cheat Sheet: Linear Algebra in Python 

<p>Even though the data.frame object is one of the core objects to hold data in R, you'll find that it's not really efficient when you're working with time series data. You'll find yourself wanting a more flexible time series class in R that offers a variety of methods to manipulate your data.</p>
<p>&nbsp;xts &nbsp;or the Extensible Time Series&nbsp;is one of such packages that offers such a time series object. It's a powerful R package&nbsp;that&nbsp;provides an extensible time series class, enabling uniform handling of many R time series classes by extending zoo, which is the package that is the creator for an S3 class of indexed totally ordered observations which includes irregular time series.</p>
<p><tt>xts</tt> has a lot to offer to make your time series analysis fast and mistake free, but it can take some time to get used to it.&nbsp;</p>
<p>This xts cheat sheet provides you not only with an overview of the xts object, how to create and inspect them, but also goes deeper into how you can manipulate time series with xts: you'll see how to replace and update values, how to select, index and subset your objects, how to handle missing values and how to perform arithmetic operations.</p>
<p>Click on the button below to see (and download) the xts cheat sheet:&nbsp;</p>
<p><a href="http://datacamp-community-prod.s3.amazonaws.com/72771032-0653-4d87-a798-4a83879e99c8" target="_blank" rel="noopener"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1625838439/xts_Cheat_Sheet-_Time_Series_in_R_nbiik0.png" alt="" /></a></p>
<p>(Click above to download a printable version or read the online version below.)&nbsp;</p>
<p>This cheat sheet will help you to get yourself up to speed in no time!&nbsp;</p>
<div id="scoped-content">
<h2>R For Data Science Cheat Sheet: xts</h2>
<p>eXtensible Time Series (xts) is a powerful package that provides an extensible time series class, enabling uniform handling of many R time series classes by extending zoo.</p>
<p>Load the package as follows:</p>
<pre class="language-r"><code>library(xts)</code></pre>
<h3>Xts Objects</h3>
<p>xts objects have three main components:</p>
<ul>
<li>coredata: always a matrix for xts objects</li>
<li>index: vector of any Date, POSIXct, chron, yearmon, yearqtr, or DateTime classes</li>
<li>xtsAttributes: arbitrary attributes</li>
</ul>
<h2>Creating xts Objects</h2>
<pre class="language-r"><code>xts1 &lt;- xts(x=1:10, order.by=Sys.Date()-1:10)
data &lt;- rnorm(5)
dates &lt;- seq(as.Date("2017-05-01"), length=5, by="days")
xts2 &lt;- xts(x=data, order.by=dates)
xts3 &lt;- xts(x=rnorm(10), order.by=as.POSIXct(Sys.Date()+1:10), born=as.POSIXct("1899-05-08")
xts4 &lt;- xts(x=1:10, order.by=Sys.Date()+1:10)</code></pre>
<h3>Convert To And From xts</h3>
<pre class="language-r"><code>data(AirPassengers)
xts5 &lt;- as.xts(AirPassengers)</code></pre>
<h3>Import From Files</h3>
<pre class="language-r"><code>dat &lt;- read.csv(tmp_file)
xts(dat, order.by=as.Date(rownames(dat),"%m/%d/%Y"))
dat_zoo &lt;- read.zoo(tmp_file, index.column=0, sep=",", format="%m/%d/%Y")
dat_zoo &lt;- read.zoo(tmp,sep=",",FUN=as.yearmon)
dat_xts &lt;- as.xts(dat_zoo)</code></pre>
<h2>Inspect Your Data</h2>
<p>Extract core data of objects</p>
<pre class="language-r"><code>core_data &lt;- coredata(xts2)</code></pre>
<p>Extract index from objects</p>
<pre class="language-r"><code>index(xts1)</code></pre>
<h3>Class Attributes</h3>
<p>Get index class</p>
<pre class="language-r"><code>indexClass(xts2)</code></pre>
<p>Replacing index class</p>
<pre class="language-r"><code>indexClass(convertIndex(xts,'POSIXct'))</code></pre>
<p>Get index class</p>
<pre class="language-r"><code>indexTZ(xts5)</code></pre>
<p>Change format of time display</p>
<pre class="language-r"><code>indexFormat(xts5) &lt;- "%Y-%m-%d"</code></pre>
<h3>Time Zones</h3>
<p>Change the time zone</p>
<pre class="language-r"><code>tzone(xts1) &lt;- "Asia/Hong_Kong"</code></pre>
<p>Extract the current time zone</p>
<pre class="language-r"><code>tzone(xts1)</code></pre>
<h3>Periods, Periodicity &amp; Timestamps</h3>
<p>Estimate frequency of observations</p>
<pre class="language-r"><code>periodicity(xts5)</code></pre>
<p>Convert xts5 to yearly OHLC</p>
<pre class="language-r"><code>to.yearly(xts5)</code></pre>
<p>Convert xts3 to monthly OHLC</p>
<pre class="language-r"><code>to.monthly(xts3)</code></pre>
<p>Convert xts5 to quarterly OHLC</p>
<pre class="language-r"><code>to.quarterly(xts5)</code></pre>
<p>Convert to quarterly OHLC</p>
<pre class="language-r"><code>to.period(xts5,period="quarters")</code></pre>
<p>Convert to yearly OHLC</p>
<pre class="language-r"><code>to.period(xts5,period="years")</code></pre>
<p>Count the months in xts5</p>
<pre class="language-r"><code>nmonths(xts5)</code></pre>
<p>Count the quarters in xts5</p>
<pre class="language-r"><code>nquarters(xts5)</code></pre>
<p>Count the years in xts5</p>
<pre class="language-r"><code>nyears(xts5)</code></pre>
<p>Make index unique</p>
<pre class="language-r"><code>make.index.unique(xts3,eps=1e-4)</code></pre>
<p>Remove duplicate times</p>
<pre class="language-r"><code>make.index.unique(xts3,drop=TRUE)</code></pre>
<p>Round index time to the next n seconds</p>
<pre class="language-r"><code>align.time(xts3, n=3600)</code></pre>
<h3>Other Useful Functions</h3>
<p>Extract raw numeric index of <tt>xts1</tt></p>
<pre class="language-r"><code>.index(xts4)</code></pre>
<p>value of weekday&nbsp;in index of xts3</p>
<pre class="language-r"><code>.indexwday(xts3)</code></pre>
<p>Value of hour in index of xts3</p>
<pre class="language-r"><code>.indexhour(xts3)</code></pre>
<p>Extract first observation of xts3&nbsp;</p>
<pre class="language-r"><code>start(xts3)</code></pre>
<p>Extract last observation of xts4&nbsp;</p>
<pre class="language-r"><code>end(xts4)</code></pre>
<p>Display structure of xts3&nbsp;</p>
<pre class="language-r"><code>str(xts3)</code></pre>
<p>Extract raw numeric index of xts1</p>
<pre class="language-r"><code>time(xts1)</code></pre>
<p>First part of xts2</p>
<pre class="language-r"><code>head(xts2)</code></pre>
<p>Last part of xts2&nbsp;</p>
<pre class="language-r"><code>tail(xts2)</code></pre>
<p>&nbsp;</p>
<h2>Export xts Objects</h2>
<pre class="language-r"><code>data_xts &lt;- as.xts(matrix)
tmp &lt;- tempfile()
write.zoo(data_xts,sep=",",file=tmp)</code></pre>
<h2>Replace &amp; Update</h2>
<p>Replace values in xts2 on dates with <tt>0</tt>&nbsp;</p>
<pre class="language-r"><code>xts2[dates] &lt;- 0 </code></pre>
<p>Replace dates from 1961 with NA&nbsp;</p>
<pre class="language-r"><code>xts5["1961"] &lt;- NA</code></pre>
<p>Replace the value at 1 specific index with NA</p>
<pre class="language-r"><code> xts2["2016-05-02"] &lt;- NA  </code></pre>
<pre>&nbsp;&nbsp;</pre>
<h2>Applying Functions</h2>
<p>Locate endpoints by time&nbsp;</p>
<pre class="language-r"><code>ep1 &lt;- endpoints(xts4,on="weeks",k=2)  
ep2 &lt;- endpoints(xts5,on="years")</code></pre>
<p>Calculate the yearly mean&nbsp;</p>
<pre class="language-r"><code>period.apply(xts5,INDEX=ep2,FUN=mean)</code></pre>
<p>Split xts5 by year</p>
<pre class="language-r"><code>xts5_yearly &lt;- split(xts5,f="years")</code></pre>
<p>Create a list of yearly means&nbsp; &nbsp;</p>
<pre class="language-r"><code>lapply(xts5_yearly,FUN=mean) </code></pre>
<p>Find the last observation in each year in xts5</p>
<pre class="language-r"><code>do.call(rbind,  lapply(split(xts5,"years"), function(w) last(w,n="1 month")))</code></pre>
<p>Calculate cumulative annual passengers</p>
<pre class="language-r"><code>do.call(rbind,  lapply(split(xts5,"years"),  cumsum))</code></pre>
<p>Apply standard deviation&nbsp;to rolling margins of xts5</p>
<pre class="language-r"><code>rollapply(xts5, 3, sd) </code></pre>
<h2>Selecting, Subsetting &amp; Indexing</h2>
<h3>Select</h3>
<pre class="language-r"><code>mar55 &lt;- xts5["1955-03"] #Get value for March 1955</code></pre>
<h3>Subset</h3>
<p>Get all data from 1954&nbsp;</p>
<pre class="language-r"><code>xts5_1954 &lt;- xts5["1954"] </code></pre>
<p>Extract data from Jan to March &lsquo;54&nbsp;</p>
<pre class="language-r"><code>xts5_janmarch &lt;- xts5["1954/1954-03"]</code></pre>
<p>Get all data until March &lsquo;54&nbsp;&nbsp;</p>
<pre class="language-r"><code>xts5_janmarch &lt;- xts5["/1954-03"] </code></pre>
<p>Subset xts4 using ep2&nbsp;</p>
<pre class="language-r"><code>xts4[ep1]</code></pre>
<h3>first() and last()</h3>
<pre class="language-r"><code>first(xts4,'1 week') #Extract first 1 week
first(last(xts4,'1 week'),'3 days') #Get first 3 days of the last week of data</code></pre>
<h3>Indexing</h3>
<p>Extract rows with the index of xts3&nbsp;</p>
<pre class="language-r"><code>xts2[index(xts3)] </code></pre>
<p>Extract rows using the vector days&nbsp;</p>
<pre class="language-r"><code>days &lt;- c("2017-05-03","2017-05-23") 
xts3[days]</code></pre>
<p>Extract rows using days as POSIXct&nbsp;</p>
<pre class="language-r"><code>xts2[as.POSIXct(days,tz="UTC")] </code></pre>
<p>Index of weekend days</p>
<pre class="language-r"><code>index&lt;-which(.indexwday(xts1)==0|.indexwday(xts1)==6) </code></pre>
<p>Extract weekend days of xts1&nbsp;</p>
<pre class="language-r"><code>xts1[index]</code></pre>
<h2>Missing Values</h2>
<p>Omit NA values in xts5&nbsp;</p>
<pre class="language-r"><code>na.omit(xts5)</code></pre>
<p>Fill missing values in xts2&nbsp;using last observation</p>
<pre class="language-r"><code>xts_last &lt;- na.locf(xts2)</code></pre>
<p>Fill missing values in xts2 using next observation</p>
<pre class="language-r"><code>xts_last &lt;- na.locf(xts2,  fromLast=TRUE)</code></pre>
<p>Interpolate NAs</p>
<pre class="language-r"><code>na.approx(xts2) </code></pre>
<h2>Arithmetic Operations</h2>
<h3>coredata() or as.numeric()</h3>
<pre class="language-r"><code>xts3 + as.numeric(xts2) #Addition
xts3 * as.numeric(xts4) #Multiplication
coredata(xts4) - xts3 #Subtraction
coredata(xts4) / xts3 #Division</code></pre>
<h3>Shifting Index Values</h3>
<p>Period-over-period differences&nbsp;</p>
<pre class="language-r"><code>xts5 - lag(xts5)</code></pre>
<p>Lagged differences</p>
<pre class="language-r"><code>diff(xts5,lag=12,differences=1) </code></pre>
<h3>Reindexing</h3>
<pre class="language-r"><code>xts1 + merge(xts2,index(xts1),fill=0) #Addition
xts1 - merge(xts2,index(xts1),fill=na.locf) #Subtraction</code></pre>
<h2>Merging</h2>
<pre class="language-r"><code>merge(xts2,xts1,join='inner') # Inner join of xts2 and xts1
merge(xts2,xts1,join='left',fill=0) #Left join of xts2 and xts1,
rbind(xts1, xts4)</code></pre>
<h2>Going Further</h2>
<p>Want to know more about xts? Check out DataCamp's <a href="https://www.datacamp.com/courses/manipulating-time-series-data-in-r-with-xts-zoo">Manipulating Time Series Data in R with </a><a href="https://www.datacamp.com/courses/manipulating-time-series-data-in-r-with-xts-zoo">xts</a><a href="https://www.datacamp.com/courses/manipulating-time-series-data-in-r-with-xts-zoo">&nbsp;&amp; zoo</a>&nbsp;course!&nbsp;</p>
</div>

Get started on time series in R with this xts cheat sheet, with code examples. 

xts Cheat Sheet: Time Series in R

<p>Given the fact that it's one of the fundamental packages for scientific computing, NumPy is one of the packages that you must be able to use and know if you want to&nbsp;do data science with Python. It offers a great alternative to Python lists, as NumPy arrays are more compact, allow faster access in reading and writing items, and are more convenient and more efficient overall.&nbsp;</p>
<p>In addition,&nbsp;it's (partly) the fundament of other important&nbsp;packages that are used for data manipulation and machine learning which you might already know, namely, Pandas, Scikit-Learn and SciPy:</p>
<ul>
<li>The Pandas data manipulation library builds on NumPy, but instead of the arrays, it makes use of two other fundamental data structures: Series and DataFrames,</li>
<li>SciPy builds on Numpy to&nbsp;provide&nbsp;a large number of functions that operate on NumPy arrays, and</li>
<li>The machine learning library Scikit-Learn builds not only on NumPy, but also on&nbsp;SciPy and Matplotlib.&nbsp;</li>
</ul>
<p>&nbsp;</p>
<p>You see, this Python library is a must-know: if you know how to work with it, you'll also gain a better understanding of the other Python data science tools that you'll undoubtedly be using.&nbsp;</p>
<p>It's a win-win situation, right?</p>
<p>Nevertheless, just like any other library, NumPy can come off as quite overwhelming at start; What are the very basics that you need to know in order to get started with this data analysis library?</p>
<p>This cheat sheet means to give you a good overview of the possibilities that this library has to offer.&nbsp;</p>
<p>Go and check it out for yourself!</p>
<p><a href="http://datacamp-community-prod.s3.amazonaws.com/ba1fe95a-8b70-4d2f-95b0-bc954e9071b0" target="_blank" rel="noopener"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1634603461/Screen_Shot_2021-10-18_at_8.27.05_PM_nweo4x.png" /></a></p>
<p>You'll see that this cheat sheet covers the basics of NumPy that you need to get started: it provides a brief explanation of what the Python library has to offer and what the array data structure looks like, and goes on to summarize topics such as array creation, I/O, array examination, array mathematics, copying and sorting arrays, selection of array elements&nbsp;and shape manipulation.</p>
<p>NumPy arrays are often preferred over Python lists, and you'll see that selecting elements from arrays is very similar to selecting elements from lists.</p>
<p>Do you want to know more? Check out DataCamp's&nbsp;<a href="https://www.datacamp.com/community/tutorials/18-most-common-python-list-questions-learn-python/">Python list&nbsp;tutorial.&nbsp;</a></p>
<p>PS.&nbsp;Don't miss our other Python cheat cheets for data science that cover&nbsp;<a href="https://www.datacamp.com/community/blog/scikit-learn-cheat-sheet/">Scikit-Learn</a>,&nbsp;<a href="https://www.datacamp.com/community/blog/bokeh-cheat-sheet-python/">Bokeh</a>, <a href="https://www.datacamp.com/community/blog/python-pandas-cheat-sheet/">Pandas</a> and the <a href="https://www.datacamp.com/community/tutorials/python-data-science-cheat-sheet-basics/">Python basics.&nbsp;</a></p>
<p><span style="font-size: 18pt;"><strong>NumPy</strong></span></p>
<p>The NumPy library is the core library for scientific computing in Python. It provides a&nbsp; high-performance multidimensional array object, and tools for working with these arrays.&nbsp;&nbsp;</p>
<p>Use the following improt convention:&nbsp;&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt; import numpy as np</code></pre>
<p><strong>Numpy Arrays&nbsp;</strong></p>
<p><img src="https://res.cloudinary.com/dyd911kmh/image/upload/v1649686329/array_2a1fcdf391.png" alt="" /></p>
<h2>Creating Arrays&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; a = np.array([1,2,3])
&gt;&gt;&gt; b = np.array([(1.5,2,3), (4,5,6)], dtype = float)
&gt;&gt;&gt; c = np.array([[(1.5,2,3), (4,5,6)],[(3,2,1), (4,5,6)]], dtype = float)</code></pre>
<h3>Initial Placeholders&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; np.zeros((3,4)) #Create an array of zeros
&gt;&gt;&gt; np.ones((2,3,4),dtype=np.int16) #Create an array of ones
&gt;&gt;&gt; d = np.arange(10,25,5)#Create an array of evenly spaced values (step value)
&gt;&gt;&gt; np.linspace(0,2,9) #Create an array of evenlyspaced values (number of samples)
&gt;&gt;&gt; e = np.full((2,2),7)#Create a constant array
&gt;&gt;&gt; f = np.eye(2) #Create a 2X2 identity matrix
&gt;&gt;&gt; np.random.random((2,2)) #Create an array with random values
&gt;&gt;&gt; np.empty((3,2)) #Create an empty array
</code></pre>
<h2>I/O&nbsp;</h2>
<h3>Saving &amp; Loading on Disk&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; np.save('my_array' , a)
&gt;&gt;&gt; np.savez( 'array.npz', a, b)
&gt;&gt;&gt; np.load( 'my_array.npy')</code></pre>
<h3>Saving &amp; Loading Text Files&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; np.loadtxt("myfile.txt")
&gt;&gt;&gt; np.genfromtxt("my_file.csv", delimiter= ',')
&gt;&gt;&gt; np.savetxt( "myarray.txt", a, delimiter= " ")</code></pre>
<h2>Asking For Help&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; np.info(np.ndarray.dtype)</code></pre>
<h2>Inspecting Your Array&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; a.shape #Array dimensions
&gt;&gt;&gt; len(a)#Length of array
&gt;&gt;&gt; b.ndim #Number of array dimensions
&gt;&gt;&gt; e.size #Number of array elements
&gt;&gt;&gt; b.dtype  #Data type of array elements
&gt;&gt;&gt; b.dtype.name  #Name of data type
&gt;&gt;&gt; b.astype(int). #Convert an array to a different type</code></pre>
<h2>Data Types&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; np.int64 #Signed 64-bit integer types
&gt;&gt;&gt; np.float32. #Standard double-precision floating point
&gt;&gt;&gt; np.complex. #Complex numbers represented by 128 floats
&gt;&gt;&gt; np.bool  #Boolean type storing TRUE and FALSE values
&gt;&gt;&gt; np.object #Python object type
&gt;&gt;&gt; np.string_ #Fixed-length string type
&gt;&gt;&gt; np.unicode_ #Fixed-length unicode type</code></pre>
<h2>Array Mathematics&nbsp;</h2>
<h3>Arithmetic Operations&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; g = a - b. #Subtraction
   array([[-0.5,0. ,0.], [-3. , -3. , -3. ]])
&gt;&gt;&gt; np.subtract(a,b) #Subtraction
&gt;&gt;&gt; b + a #Addition 
  array([[ 2.5, 4. , 6.],[5. ,7. ,9. ]])
&gt;&gt;&gt; np.add(b,a) #Addition 
&gt;&gt;&gt; a/b #Division 
 array([[0.66666667,1. ,1.],[0.25 ,0.4 ,0.5 ]])
&gt;&gt;&gt; np.divide(a,b) #Division 
&gt;&gt;&gt; a * b #Multiplication 
  array([[1.5, 4. ,9.],[ 4. , 10. , 18. ]])
&gt;&gt;&gt; np.multiply(a,b) #Multiplication 
&gt;&gt;&gt; np.exp(b) #Exponentiation
&gt;&gt;&gt; np.sqrt(b) #Square root
&gt;&gt;&gt; np.sin(a)  #Print sines of an array
&gt;&gt;&gt; np.cos(b) #Elementwise cosine
&gt;&gt;&gt; np.log(a)#Elementwise natural logarithm
&gt;&gt;&gt; e.dot(f) #Dot product 
 array([[7.,7.],[7.,7.]])</code></pre>
<h3>Comparison&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; a == b #Elementwise comparison

 array([[False , True, True],
             [ False,False ,False ]], dtype=bool)
&gt;&gt;&gt; a&lt; 2 #Elementwise comparison
   array([True, False, False], dtype=bool)
&gt;&gt;&gt; np.array_equal(a, b) #Arraywise comparison</code></pre>
<h2>Copying Arrays&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt;h = a.view()#Create a view of the array with the same data
&gt;&gt;&gt; np.copy(a) #Create a copy of the array
&gt;&gt;&gt;h = a.copy() #Create a deep copy of the array</code></pre>
<h2>Sorting Arrays&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; a.sort() #Sort an array
&gt;&gt;&gt; c.sort(axis=0) #Sort the elements of an array's axis</code></pre>
<h2>Subsetting, Slicing, Indexing&nbsp;</h2>
<p>Subsetting</p>
<pre class="language-python"><code>&gt;&gt;&gt; a[2] #Select the element at the 2nd index
  3
&gt;&gt;&gt; b[1,2] #Select the element at row 1 column 2(equivalent to b[1][2])
  6.0</code></pre>
<p>Slicing</p>
<pre class="language-python"><code>&gt;&gt;&gt; a[0:2]#Select items at index 0 and 1
 array([1, 2])
&gt;&gt;&gt; b[0:2,1] #Select items at rows 0 and 1 in column 1
  array([ 2.,5.])
&gt;&gt;&gt; b[:1] 
#Select all items at row0(equivalent to b[0:1, :])
  array([[1.5, 2., 3.]])
 &gt;&gt;&gt; c[1,...] #Same as[1,:,:]
 array([[[ 3., 2.,1.],[ 4.,5., 6.]]])
&gt;&gt;&gt; a[ : : -1] #Reversed array a array([3, 2, 1])</code></pre>
<p>Boolean Indexing&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt; a[a&lt;2] #Select elements from a less than 2
 array([1])</code></pre>
<p>Fancy Indexing&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt; b[[1,0,1, 0],[0,1, 2, 0]] #Select elements(1,0),(0,1),(1,2) and(0,0)
  array([ 4. , 2. , 6. ,1.5])
&gt;&gt;&gt; b[[1,0,1, 0]][:,[0,1,2,0]] #Select a subset of the matrix&rsquo;s rows and columns
 array([[ 4. ,5. , 6. , 4.],[1.5, 2. , 3. ,1.5],[ 4. ,5. , 6. , 4.],[1.5, 2. , 3. ,1.5]])

</code></pre>
<h2>Array Manipulation&nbsp;</h2>
<p>Transposing Array&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt; i = np.transpose(b) #Permute array dimensions
&gt;&gt;&gt; i.T #Permute array dimensions</code></pre>
<p>Changing Array Shape&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt; b.ravel() #Flatten the array
&gt;&gt;&gt; g.reshape(3, -2) #Reshape, but don&rsquo;t change data</code></pre>
<p>Adding/Removing Elements&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt;h.resize((2,6)) #Return a new arraywith shape(2,6)
&gt;&gt;&gt; np.append(h,g) #Append items to an array
&gt;&gt;&gt; np.insert(a,1,5)  #Insert items in an array
&gt;&gt;&gt; np.delete(a,[1])  #Delete items from an array</code></pre>
<p>Combining Arrays&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt; np.concatenate((a,d),axis=0) #Concatenate arrays
 array([1, 2, 3, 10, 15, 20])
&gt;&gt;&gt; np.vstack((a,b) #Stack arrays vertically(row wise)
 array([[1. , 2. , 3.],[1.5, 2. , 3.],[ 4. ,5. , 6. ]])
&gt;&gt;&gt; np.r_[e,f] #Stack arrays vertically(row wise)
&gt;&gt;&gt; np.hstack((e,f)) #Stack arrays horizontally(column wise)
 array([[7.,7.,1.,0.],[7.,7.,0.,1.]])
&gt;&gt;&gt; np.column_stack((a,d)) #Create stacked column wise arrays
 array([[1, 10],[ 2, 15],[ 3, 20]])
&gt;&gt;&gt; np.c_[a,d] #Create stacked column wise arrays</code></pre>
<p>Splitting Arrays&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt; np.hsplit(a,3) #Split the array horizontally at the 3rd index
  [array([1]),array([2]),array([3])]
&gt;&gt;&gt; np.vsplit(c,2) #Split the array vertically at the 2nd index
  [array([[[ 1.5, 2. ,1.],[ 4. ,5. , 6. ]]]),
   array([[[ 3., 2., 3.],[ 4.,5., 6.]]])]</code></pre>

This Python cheat sheet is a quick reference for NumPy beginners.

NumPy Cheat Sheet: Data Analysis in Python

This cheat sheet is a quick reference for data wrangling with Pandas, complete with code samples.

Pandas Cheat Sheet: Data Wrangling in Python

<p>You'll probably know the Jupyter notebooks pretty well - it's one of the most well-known parts of the Jupyter ecosystem! If you haven't explored the ecosystem yet or if you simply want to know more about it, don't hesitate to go and explore it&nbsp;<a href="https://www.datacamp.com/community/blog/www.jupyter.org">here</a>!.</p>
<p>For those who are new to Project Jupyter, the Jupyter Notebook Application produces documents that contain a mix of executable code, text elements, and even HTML, which makes it th&eacute; ideal place to bring together an analysis description and its results as well as to perform data analysis in real time. This, combined with its many useful functionalities, explains why the Jupyter Notebook is a&nbsp;<a href="https://www.datacamp.com/community/tutorials/data-science-python-ide">one of the data scientist's preferred development environments environments</a>&nbsp;that allows for interactive, reproducible data science analysis, computation and communication.</p>
<p>One of the other great things about the Jupyter notebooks?</p>
<p>They're super easy to get started with! You might have already noticed this when you read DataCamp's&nbsp;<a href="https://www.datacamp.com/community/tutorials/tutorial-jupyter-notebook">definitive guide to Jupyter Notebook</a>. However, when you first enter in the application, you might have to find your way around the variety of functionalities that are presented to you: from saving your current notebook to adding or moving cells in the notebook or embedding current widgets in your notebook - without a doubt, there's a lot out there to discover when you first get started!</p>
<p>That's why DataCamp made a Jupyter Notebook cheat sheet for those who are just starting out and that want to have some help to find their way around.</p>
<p>Note&nbsp;also that the Jupyter Notebook Application has a handy "Help" menu that includes a full-blown User Interface Tour! -- No worries, we also included this in the cheat sheet :)</p>
<p>Check it out here:</p>
<p><a href="http://datacamp-community-prod.s3.amazonaws.com/21fdc814-3f08-4aa9-90fa-247eedefd655" target="_blank" rel="noopener"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1625839536/Jupyter_Notebook_Cheat_Sheet_ntmalw.png" alt="Jupyter Notebook cheat sheet" /></a></p>
<p>In short, this cheat sheet will help you to kickstart your data science projects, however small or big they might be: with of some screenshots and explanations, you'll be a Jupyter Notebook expert in no time!</p>
<p>So what are you waiting for? Time to get started!</p>

This Jupyter Notebook cheat sheet will help you to find your way around the well-known Notebook App, a subproject of Project Jupyter.

Jupyter Notebook Cheat Sheet

<p>Before doing any data cleaning, wrangling, visualizing, ... You'll need to know how to get data into Python. As you know, there are many ways to import data into Python, depending also on which files you're dealing with.</p>
<p>However, you'll most often make use of the pandas and the NumPy libraries: The pandas library is one of the most preferred tools for data scientists to do data manipulation and analysis, next to matplotlib for data visualization and NumPy, the fundamental library for scientific computing in Python on which Pandas was built.</p>
<p>In this importing data in Python cheat sheet, you'll find some NumPy and pandas functions, together with functions that are built in the Python programming language, that will help you to get your data in Python fast!</p>
<p>This quick guide helps you to learn the basics of importing data in Python that you will need to get started on cleaning and wrangling your data!</p>
<p><a href="http://datacamp-community-prod.s3.amazonaws.com/72e88aa1-b4f2-4658-9d86-15becf8263df"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1625837839/Importing_Data_in_Python_Cheat_Sheet_osn6zr.png" alt="data import python cheat sheet" /></a></p>
<p>The Importing Data in Python cheat sheet will guide you through the basics of getting your data in your workspace: you'll not only learn how to import flat files such as text files, but you'll also see how you can get data from files native to other software such as Excel spreadsheets, Stata, SAS and MATLAB files and relational databases. On top of that, you'll get some more information on how to ask for help, how to navigate your filesystem and how to start exploring your data.</p>
<p>In short, everything that you need to kickstart your data science learning with Python!</p>
<p>Do you want to learn more? Start the <a href="https://www.datacamp.com/courses/importing-data-in-python-part-1/">Importing Data in Python course</a> for free now or try out our <a href="https://www.datacamp.com/community/tutorials/python-excel-tutorial">Python Excel tutorial</a>!</p>
<p>Also, don't miss out on our <a href="https://www.datacamp.com/community/tutorials/python-data-science-cheat-sheet-basics">Python cheat sheet</a> for data science, or the many others we have <a href="https://www.datacamp.com/community/data-science-cheatsheets">here</a> on our Community!</p>
<h2>Importing Data in Python&nbsp;</h2>
<p><strong>Most of the time, you'll use either NumPy or pandas to import your data:</strong></p>
<pre class="language-python"><code>&gt;&gt;&gt; import numpy as np
&gt;&gt;&gt; import pandas as pd
</code></pre>
<h2>Help&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; np.info(np.ndarray.dtype)
&gt;&gt;&gt; help(pd.read_csv)
</code></pre>
<h2>Text Files&nbsp;</h2>
<h3>Plain Text Files&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt;filename= 'huck_finn.txt'
&gt;&gt;&gt;file= open(filename, mode='r') #Open the file for reading
&gt;&gt;&gt;text= file.read() #Read a file's contents
&gt;&gt;&gt; print(file.closed) #Check whether file is closed
&gt;&gt;&gt; file.close() #Close file
&gt;&gt;&gt; print( text)
</code></pre>
<p>Use the content manager with:</p>
<pre class="language-python"><code>&gt;&gt;&gt; with open('huck_finn.txt', 'r') as file: 
    print(file.readline()) #Read a single line 
    print(file.readline()) 
    print(file.readline())</code></pre>
<h3>Table Data: Flat Files&nbsp;</h3>
<h4>Importing Flat Files with NumPy&nbsp;</h4>
<pre class="language-python"><code>&gt;&gt;&gt;filename= 'huck_finn.txt'
&gt;&gt;&gt;file= open(filename, mode='r') #Open the file for reading
&gt;&gt;&gt;text= file.read() #Read a file's contents
&gt;&gt;&gt; print(file.closed) #Check whether file is closed
&gt;&gt;&gt; file.close() #Close file
&gt;&gt;&gt; print(text)
</code></pre>
<h4>Files with one data type:&nbsp;</h4>
<pre class="language-python"><code>&gt;&gt;&gt;filename= 'mnist.txt'
&gt;&gt;&gt;data= np.loadtxt(filename,
    delimiter=',', #String used to separate values 
    skiprows=2, #Skip the first 2 lines 
    usecols=[0,2], #Read the 1st and 3rd column 
    dtype=str) #The type of the resulting array
</code></pre>
<h4>Files with mixed data type&nbsp;</h4>
<pre class="language-python"><code>&gt;&gt;&gt;filename= 'titanic.csv'
&gt;&gt;&gt;data= np.genfromtxt(filename,
    delimiter=',',
    names=True, #Look for column header
    dtype=None)
&gt;&gt;&gt; data_array = np.recfromcsv(filename)
#The default dtype of the np.recfromcsv() function is None
</code></pre>
<h4>Importing Flat Files with Pandas&nbsp;</h4>
<pre class="language-python"><code>&gt;&gt;&gt;filename= 'winequality-red.csv'
&gt;&gt;&gt;data= pd.read_csv(filename,
         nrows=5, #Number of rows of file to read 
         header=None, #Row number to use as col names 
         sep='\t', #Delimiter  to use 
         comment='#', #Character to split comments 
         na_values=[""]) #String to recognize as NA/NaN
</code></pre>
<h2>Exploring Your Data&nbsp;</h2>
<h3>NumPy Arrays&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; data_array.dtype #Data type of array elements
&gt;&gt;&gt; data_array.shape #Array  dimensions
&gt;&gt;&gt; len(data_array) #Length of array
</code></pre>
<h3>Pandas DataFrames&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; df.head() #Return first DataFrame rows
&gt;&gt;&gt; df.tail() #Return last DataFrame rows
&gt;&gt;&gt; df.index #Describe index
&gt;&gt;&gt; df.columns #Describe DataFrame columns
&gt;&gt;&gt; df.info() #Info an DataFrame
&gt;&gt;&gt; data_array = data.values #Convert a DataFrame to an a NumPy array
</code></pre>
<h2>SAS File&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; from sas7bdat import SAS7BDAT
&gt;&gt;&gt; with SAS7BDAT('urbanpop.sas7bdat') as file: df_sas = file.to_data_frame()
</code></pre>
<h2>Stata File&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt;data= pd.read_stata('urbanpop.dta')</code></pre>
<h2>Excel Spreadsheets&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt;file= 'urbanpop.xlsx'
&gt;&gt;&gt;data= pd.ExcelFile(file)
&gt;&gt;&gt; df sheet2 = data.parse('1960-1966',
          skiprows=[0], 
          names=['Country', 'AAM: War(2002)'])
&gt;&gt;&gt; df sheetl = data.parse(0,
          parse_cols=[0], 
          skiprows=[0], 
          names=['Country'])
</code></pre>
<p>To access the sheet names, use the sheet_names attribute:</p>
<pre class="language-python"><code>&gt;&gt;&gt; data.sheet_names</code></pre>
<h2>Relational Databases</h2>
<pre class="language-python"><code>&gt;&gt;&gt; from sqlalchemy import create_engine
&gt;&gt;&gt;engine= create_engine('sqlite://Northwind.sqlite')
</code></pre>
<p>Use the table_names() method to fetch a list of table names:</p>
<pre class="language-python"><code>&gt;&gt;&gt; table_names = engine.table_names()</code></pre>
<h3>Querying Relational Databases&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt;con= engine.connect()
&gt;&gt;&gt; rs= con.execute("SELECT * FROM Orders")
&gt;&gt;&gt; df = pd.DataFrame(rs.fetchall())
&gt;&gt;&gt; df.columns = rs.keys()
&gt;&gt;&gt; con.close()

</code></pre>
<p>&nbsp;</p>
<p>Using the context manager with</p>
<pre class="language-python"><code>&gt;&gt;&gt; with engine.connect() as con:
          rs= con.execute("SELECT OrderID FROM Orders") 
          df = pd.DataFrame(rs.fetchmany(size=5)) 
          df.columns = rs.keys()</code></pre>
<h3>Querying Relational Databases with Pandas&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; df = pd.read_sql_query("SELECT * FROM Orders", engine)</code></pre>
<h2>Pickled Files</h2>
<pre class="language-python"><code>&gt;&gt;&gt; import pickle
&gt;&gt;&gt; with open('pickled_fruit.pkl', 'rb') as file: 
          pickled_data = pickle.load(file)
</code></pre>
<h2>Matlab Files&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; import scipy.io
&gt;&gt;&gt;filename= 'workspace.mat'
&gt;&gt;&gt;mat= scipy.io.loadmat(filename)
</code></pre>
<h2>HDF5 Files&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; import h5py
&gt;&gt;&gt;filename= 'H-Hl LDSC 4 v1-815411200-4096.hdf5'
&gt;&gt;&gt;data= h5py.File(filename, 'r')
</code></pre>
<h2>Exploring Dictionaries&nbsp;</h2>
<h3><strong>Querying relational databases with pandas</strong></h3>
<pre class="language-python"><code>&gt;&gt;&gt; print(mat.keys()) #Print dictionary keys
&gt;&gt;&gt; for key in data.keys(): #Print dictionary keys
              print(key)
     meta 
     quality 
     strain
&gt;&gt;&gt; pickled_data.values() #Return dictionary values
&gt;&gt;&gt; print(mat.items()) #Returns items in list format of (key, value) tuple pairs
</code></pre>
<h3><strong>Accessing Data Items with Keys</strong></h3>
<pre class="language-python"><code>&gt;&gt;&gt; for key in data ['meta'].keys() #Explore the HDF5
structure
               print(key) 
     Description 
     DescriptionURL 
     Detector
     Duration 
     GPSstart 
     Observatory 
     Type 
     UTCstart
#Retrieve the value for a key
&gt;&gt;&gt; print(data['meta']['Description'].value)
</code></pre>
<h2>Navigating Your FileSystem&nbsp;</h2>
<h3>Magic Commands&nbsp;</h3>
<pre class="language-python"><code>!ls #List directory contents of files and directories
%cd .. #Change current working directory
%pwd #Return the current working directory path
</code></pre>
<h3>OS Library&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; import os
&gt;&gt;&gt; path = "/usr/tmp"
&gt;&gt;&gt; wd = os.getcwd() #Store the name of current directory in a string
&gt;&gt;&gt; os.listdir(wd) #Output contents of the directory in a list
&gt;&gt;&gt; os.chdir(path) #Change current working directory
&gt;&gt;&gt; os.rename( "test1.txt", #Rename a file
               "test2.txt")
&gt;&gt;&gt; os.remove("test1. txt") #Delete an existing file
&gt;&gt;&gt; os.mkdir("newdir") #Create a new directory
</code></pre>
<p>&nbsp;</p>
<p>&nbsp;</p>

With this Python cheat sheet, you'll have a handy reference guide to importing your data, from flat files to files native to other software, and relational databases.

Importing Data in Python Cheat Sheet

<p>Data visualization and storytelling with your data are essential skills that every data scientist needs to communicate insights gained from analyses effectively to any audience out there.&nbsp;</p>
<p>For most beginners, the first package that they use to get in touch with data visualization and storytelling is, naturally, Matplotlib: it is a Python 2D plotting library that enables users to make publication-quality figures. But, what might be even more convincing is the fact that other packages, such as Pandas, intend&nbsp;to build more plotting integration with Matplotlib as time goes on.</p>
<p>However, what might slow down beginners is the fact that this package is pretty extensive. There is so much that you can do with it and it might be hard to still keep a structure when you're learning how to work with Matplotlib. &nbsp;&nbsp;</p>
<p>DataCamp has created a Matplotlib cheat sheet for those who might already know how to use the package to their advantage to make beautiful plots in Python, but that still want to keep a one-page reference handy. Of course, for those who don't know how to work with Matplotlib, this might be the extra push be convinced and to finally get started with data visualization in Python.&nbsp;</p>
<p>(By the way, if you want to get started with this Python package, you might want to consider our <a href="https://www.datacamp.com/community/tutorials/matplotlib-tutorial-python/">Matplotlib tutorial</a>.)</p>
<p>You'll see that this cheat sheet presents you with the six basic steps that you can go through to make beautiful plots.&nbsp;</p>
<p>Check out the infographic by clicking on the button below:</p>
<p><a href="http://datacamp-community-prod.s3.amazonaws.com/e1a8f39d-71ad-4d13-9a6b-618fe1b8c9e9" target="_blank" rel="noopener"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1625838238/Matplotlib_Cheat_Sheet-_Plotting_in_Python_htbtut.png" alt="Python Matplotlib cheat sheet" /></a></p>
<p>With this handy reference, you'll familiarize yourself in no time with the basics of Matplotlib: you'll learn how you can prepare your data, create a new plot, use some basic plotting routines to your advantage, add customizations to your plots, and save, show and close the plots that you make.</p>
<p>What might have looked difficult before will definitely be more clear once you start using this cheat sheet! Use it in combination with the <a href="http://matplotlib.org/gallery.html">Matplotlib Gallery</a>, the <a href="http://matplotlib.org/2.0.0/index.html">documentation</a>&nbsp;and our <a href="https://www.datacamp.com/community/tutorials/matplotlib-tutorial-python/">tutorial</a>. &nbsp;&nbsp;</p>
<p>Also, don't miss out on our other cheat sheets for data science that cover <a href="https://www.datacamp.com/community/blog/python-scipy-cheat-sheet/">SciPy</a>,&nbsp;<a href="https://www.datacamp.com/community/blog/python-numpy-cheat-sheet/">Numpy</a>,&nbsp;<a href="https://www.datacamp.com/community/blog/scikit-learn-cheat-sheet/">Scikit-Learn</a>,&nbsp;<a href="https://www.datacamp.com/community/blog/bokeh-cheat-sheet-python/">Bokeh</a>,&nbsp;<a href="https://www.datacamp.com/community/blog/python-pandas-cheat-sheet/">Pandas</a>&nbsp;and the&nbsp;<a href="https://www.datacamp.com/community/tutorials/python-data-science-cheat-sheet-basics/">Python basics</a>.</p>
<p>&nbsp;</p>
<p><span style="font-size: 18pt;"><strong>Matplotlib</strong></span>&nbsp;</p>
<p>Matplotlib is a Python 2D plotting library which produces publication-quality figures in a variety of hardcopy formats and interactive environments across platforms.</p>
<h2>Prepare the Data&nbsp;</h2>
<h3>1D Data&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; import numpy as np
&gt;&gt;&gt; x = np.linspace(0, 10, 100)
&gt;&gt;&gt; y = np.cos(x)
&gt;&gt;&gt; z = np.sin(x)</code></pre>
<h3>2D Data or Images&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; data = 2 * np.random.random((10, 10))
&gt;&gt;&gt; data2 = 3 * np.random.random((10, 10))
&gt;&gt;&gt; Y, X = np.mgrid[-3:3:100j, -3:3:100j]
&gt;&gt;&gt; U = 1 X** 2 + Y
&gt;&gt;&gt; V = 1 + X Y**2
&gt;&gt;&gt; from matplotlib.cbook import get_sample_data
&gt;&gt;&gt; img = np.load(get_sample_data('axes_grid/bivariate_normal.npy'))</code></pre>
<h2>Create Plot</h2>
<pre class="language-python"><code>&gt;&gt;&gt; import matplotlib.pyplot as plt</code></pre>
<h3>Figure&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; fig = plt.figure()
&gt;&gt;&gt; fig2 = plt.figure(figsize=plt.figaspect(2.0))</code></pre>
<h3>Axes&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; fig.add_axes()
&gt;&gt;&gt; ax1 = fig.add_subplot(221) #row-col-num
&gt;&gt;&gt; ax3 = fig.add_subplot(212)
&gt;&gt;&gt; fig3, axes = plt.subplots(nrows=2,ncols=2)
&gt;&gt;&gt; fig4, axes2 = plt.subplots(ncols=3)</code></pre>
<h2>Save Plot&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; plt.savefig('foo.png') #Save figures
&gt;&gt;&gt; plt.savefig('foo.png',  transparent=True) #Save transparent figures</code></pre>
<h2>Show Plot</h2>
<pre class="language-python"><code>&gt;&gt;&gt; plt.show()</code></pre>
<h2>Plotting Routines&nbsp;</h2>
<h2>1D Data&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; fig, ax = plt.subplots()
&gt;&gt;&gt; lines = ax.plot(x,y) #Draw points with lines or markers connecting them
&gt;&gt;&gt; ax.scatter(x,y) #Draw unconnected points, scaled or colored
&gt;&gt;&gt; axes[0,0].bar([1,2,3],[3,4,5]) #Plot vertical rectangles (constant width)
&gt;&gt;&gt; axes[1,0].barh([0.5,1,2.5],[0,1,2]) #Plot horiontal rectangles (constant height)
&gt;&gt;&gt; axes[1,1].axhline(0.45) #Draw a horizontal line across axes
&gt;&gt;&gt; axes[0,1].axvline(0.65) #Draw a vertical line across axes
&gt;&gt;&gt; ax.fill(x,y,color='blue') #Draw filled polygons
&gt;&gt;&gt; ax.fill_between(x,y,color='yellow') #Fill between y values and 0</code></pre>
<h3>2D Data&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; fig, ax = plt.subplots()
&gt;&gt;&gt; im = ax.imshow(img, #Colormapped or RGB arrays
      cmap= 'gist_earth', 
      interpolation= 'nearest',
      vmin=-2,
      vmax=2)
&gt;&gt;&gt; axes2[0].pcolor(data2) #Pseudocolor plot of 2D array
&gt;&gt;&gt; axes2[0].pcolormesh(data) #Pseudocolor plot of 2D array
&gt;&gt;&gt; CS = plt.contour(Y,X,U) #Plot contours
&gt;&gt;&gt; axes2[2].contourf(data1) #Plot filled contours
&gt;&gt;&gt; axes2[2]= ax.clabel(CS) #Label a contour plot</code></pre>
<h3>Vector Fields&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; axes[0,1].arrow(0,0,0.5,0.5) #Add an arrow to the axes
&gt;&gt;&gt; axes[1,1].quiver(y,z) #Plot a 2D field of arrows
&gt;&gt;&gt; axes[0,1].streamplot(X,Y,U,V) #Plot a 2D field of arrows</code></pre>
<h3>Data Distributions&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; ax1.hist(y) #Plot a histogram
&gt;&gt;&gt; ax3.boxplot(y) #Make a box and whisker plot
&gt;&gt;&gt; ax3.violinplot(z)  #Make a violin plot</code></pre>
<h2>Plot Anatomy &amp; Workflow&nbsp;</h2>
<h3>Plot Anatomy&nbsp;</h3>
<p>&nbsp;y-axis &nbsp; &nbsp; &nbsp;</p>
<p><img src="https://res.cloudinary.com/dyd911kmh/image/upload/v1649685886/graph_dc34a358f7.png" alt="" /></p>
<p>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;x-axis&nbsp;</p>
<h3>Workflow&nbsp;</h3>
<p>The basic steps to creating plots with matplotlib are:<br /><br />1 Prepare Data <br />2 Create Plot <br />3 Plot <br />4 Customized Plot <br />5 Save Plot <br />6 Show Plot</p>
<pre class="language-python"><code>&gt;&gt;&gt; import matplotlib.pyplot as plt
&gt;&gt;&gt; x = [1,2,3,4]  #Step 1
&gt;&gt;&gt; y = [10,20,25,30] 
&gt;&gt;&gt; fig = plt.figure() #Step 2
&gt;&gt;&gt; ax = fig.add_subplot(111) #Step 3
&gt;&gt;&gt; ax.plot(x, y, color= 'lightblue', linewidth=3)  #Step 3, 4
&gt;&gt;&gt; ax.scatter([2,4,6],
          [5,15,25],
          color= 'darkgreen',
          marker= '^' )
&gt;&gt;&gt; ax.set_xlim(1, 6.5)
&gt;&gt;&gt; plt.savefig('foo.png' ) #Step 5
&gt;&gt;&gt; plt.show() #Step 6</code></pre>
<h2>Close and Clear&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; plt.cla()  #Clear an axis
&gt;&gt;&gt; plt.clf(). #Clear the entire figure
&gt;&gt;&gt; plt.close(). #Close a window</code></pre>
<h2>Plotting Customize Plot&nbsp;</h2>
<h3>Colors, Color Bars &amp; Color Maps&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; plt.plot(x, x, x, x**2, x, x** 3)
&gt;&gt;&gt; ax.plot(x, y, alpha = 0.4)
&gt;&gt;&gt; ax.plot(x, y, c= 'k')
&gt;&gt;&gt; fig.colorbar(im, orientation= 'horizontal')
&gt;&gt;&gt; im = ax.imshow(img,
            cmap= 'seismic' )</code></pre>
<h3>Markers&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; fig, ax = plt.subplots()
&gt;&gt;&gt; ax.scatter(x,y,marker= ".")
&gt;&gt;&gt; ax.plot(x,y,marker= "o")</code></pre>
<h3>Linestyles&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; plt.plot(x,y,linewidth=4.0)
&gt;&gt;&gt; plt.plot(x,y,ls= 'solid') 
&gt;&gt;&gt; plt.plot(x,y,ls= '--') 
&gt;&gt;&gt; plt.plot(x,y,'--' ,x**2,y**2,'-.' ) 
&gt;&gt;&gt; plt.setp(lines,color= 'r',linewidth=4.0)</code></pre>
<h3>Text &amp; Annotations&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; ax.text(1,
           -2.1, 
           'Example Graph', 
            style= 'italic' )
&gt;&gt;&gt; ax.annotate("Sine", 
xy=(8, 0),
xycoords= 'data', 
xytext=(10.5, 0),
textcoords= 'data', 
arrowprops=dict(arrowstyle= "-&gt;", 
connectionstyle="arc3"),)</code></pre>
<h3>Mathtext&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; plt.title(r '$sigma_i=15$', fontsize=20)</code></pre>
<h3>Limits, Legends and Layouts&nbsp;</h3>
<p>Limits &amp; Autoscaling&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt; ax.margins(x=0.0,y=0.1) #Add padding to a plot
&gt;&gt;&gt; ax.axis('equal')  #Set the aspect ratio of the plot to 1
&gt;&gt;&gt; ax.set(xlim=[0,10.5],ylim=[-1.5,1.5])  #Set limits for x-and y-axis
&gt;&gt;&gt; ax.set_xlim(0,10.5) #Set limits for x-axis</code></pre>
<p>Legends&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt; ax.set(title= 'An Example Axes',  #Set a title and x-and y-axis labels
            ylabel= 'Y-Axis', 
            xlabel= 'X-Axis')
&gt;&gt;&gt; ax.legend(loc= 'best')  #No overlapping plot elements</code></pre>
<p>Ticks&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt; ax.xaxis.set(ticks=range(1,5),  #Manually set x-ticks
             ticklabels=[3,100, 12,"foo" ])
&gt;&gt;&gt; ax.tick_params(axis= 'y', #Make y-ticks longer and go in and out
             direction= 'inout', 
              length=10)</code></pre>
<p>Subplot Spacing&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt; fig3.subplots_adjust(wspace=0.5,   #Adjust the spacing between subplots
             hspace=0.3,
             left=0.125,
             right=0.9,
             top=0.9,
             bottom=0.1)
&gt;&gt;&gt; fig.tight_layout() #Fit subplot(s) in to the figure area</code></pre>
<p>Axis Spines&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt; ax1.spines[ 'top'].set_visible(False) #Make the top axis line for a plot invisible
&gt;&gt;&gt; ax1.spines['bottom' ].set_position(( 'outward',10))  #Move the bottom axis line outward</code></pre>

This Matplotlib cheat sheet introduces you to the basics that you need to plot your data with Python and includes code samples. 