<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

<p>Tableau is a business intelligence tool that allows you to effectively report insights through easy-to-use customizable visualizations and dashboards. This cheat sheet is designed to get you started with Tableau and covers creating your first visualization, creating a dashboard, a data story, and more.&nbsp;</p>
<p><a href="https://s3.amazonaws.com/assets.datacamp.com/email/other/Tableau+Cheat+Sheet.pdf"><img style="display: block; margin-left: auto; margin-right: auto;" src="https://res.cloudinary.com/dyd911kmh/image/upload/v1651236733/tableau_cheat_sheet_5f7309124a.png" alt="" width="500" /></a></p>
<p style="text-align: center;"><a href="https://s3.amazonaws.com/assets.datacamp.com/email/other/Tableau+Cheat+Sheet.pdf"><em><strong>For a printable version of this cheat sheet, click on the image above</strong></em></a></p>
<h2>Why use Tableau?</h2>
<p>While there are many reasons to use Tableau &mdash; here are our top 3 reasons:</p>
<ul>
<li>Easy to use&mdash;no coding involved</li>
<li>Integrates seamlessly with any data source</li>
<li>Fast and can handle large datasets</li>
</ul>
<h2>Tableau Versions</h2>
<p>There are two main versions of Tableau:</p>
<ul>
<li><strong>Tableau Public:</strong> A free version of Tableau that lets you connect to limited data sources, create visualizations and dashboards, and publish dashboards online</li>
<li><strong>Tableau Desktop:</strong> A paid version of tableau which lets you connect to all types of data sources, allows you to save work locally, and has unlimited data sizes</li>
</ul>
<h2>Getting started with Tableau</h2>
<p>When working with Tableau, you will work with Workbooks. Workbooks contain sheets, dashboards, and stories. Similar to Microsoft Excel, a Workbook can contain multiple sheets. A sheet can be any of the following and can be accessed on the bottom left of a workbook.</p>
<ul>
<li><strong>Worksheet</strong>: A worksheet is a single view in a workbook. You can add shelves, cards, legends, visualizations, and more to a worksheet</li>
<li><strong>Dashboard</strong>: A collection of multiple worksheets used to display multiple views simultaneously</li>
<li><strong>Story</strong>: A story is a collection of multiple dashboards and/or sheets that describe a data story</li>
</ul>
<h2>The anatomy of a worksheet</h2>
<h3>The sidebar</h3>
<p>In the sidebar, you&rsquo;ll find useful panes for working with data</p>
<ul>
<li><strong>Data:</strong> The data pane on the left-hand side contains all of the fields in the currently selected data source</li>
<li><strong>Analytics:</strong> The analytics pane on the left-hand side lets you add useful insights like trend lines, error bars, and other useful summaries to visualizations</li>
</ul>
<h3>Tableau data definitions</h3>
<p>When working with data in Tableau, there are multiple definitions to be mindful of</p>
<ul>
<li><strong>Fields:</strong> Fields are all of the different columns or values in a data source or that are calculated in the workbook. They show up in the data pane and can either be dimension or measure fields</li>
<li><strong>Dimensions:</strong> A dimension is a type of field that contains qualitative values (e.g. locations, names, and departments). Dimensions dictate the amount of granularity in visualizations and help reveal nuanced details in the data</li>
<li><strong>Measures: </strong>A measure is a type of field that contains quantitative values (e.g. revenue, costs, and market sizes). When dragged into a view, this data is aggregated, which is determined by the dimensions in the view</li>
<li><strong>Data types:</strong> Every field has a data type which is determined by the type of information it contains. The available data types in Tableau include text, date values, date &amp; time values, numerical values, boolean values, geographical values, and cluster groups</li>
</ul>
<h3>The canvas</h3>
<p>The canvas is where you create your data visualizations</p>
<ul>
<li><strong>Tableau Canvas:</strong> The canvas takes up most of the screen on Tableau and is where you can add visualizations</li>
<li><strong>Rows and columns:</strong> Rows and columns dictate how the data is displayed on the canvas. When dimensions are placed, they create headers for the rows or columns while measures add quantitative values</li>
<li><strong>Marks card:</strong> The marks card allows users to add visual details such as color, size, labels, etc. to rows and columns. This is done by dragging fields from the data pane into the marks card&nbsp;</li>
</ul>
<h2>How to Create a Data Vizualization</h2>
<p class="p1"><strong>Upload a dataset&nbsp;</strong></p>
<ol class="ol1">
<li class="li1">Launch Tableau</li>
<li class="li1">In the <em>Connect</em> section, under <em>To a File</em>, press on the file format of your choice</li>
<li class="li1">For selecting an Excel file, select <em>.xlsx</em> or <em>.xlsx</em></li>
</ol>
<p class="p1"><strong>Creating your first visualization</strong></p>
<ol class="ol1">
<li class="li1">Once your file is uploaded, open a <em>Worksheet</em> and click on the <em>Data</em> pane on the left-hand side</li>
<li class="li1">Drag and drop at least one field into the <em>Columns</em> section, and one field into the <em>Rows</em> section at the top of the canvas</li>
<li class="li1">To add more detail, drag and drop a dimension into the <em>Marks</em> card (e.g. drag a dimension over the color square in the marks card to color visualization components by that dimension)</li>
<li class="li1">To a summary insight like a trendline, click on the <em>Analytics</em> pane and drag the trend line into your visualization</li>
<li class="li1">You can change the type of visualization for your data by clicking on the <em>Show Me button</em> on the top right</li>
</ol>
<h2>Data Visualization Types in Tableau</h2>
<p>Tableau provides a wide range of data visualizations. Here is a list of the most useful visualizations you have in Tableau:</p>
<ul>
<li><strong>Bar Charts:</strong> Horizontal bars used for comparing specific values across categories (e.g. sales by region)</li>
<li><strong>Stacked Bar Charts:</strong> Used to show categorical data within a bar chart (e.g., sales by region and department)</li>
<li><strong>Side by side chart: </strong>Used to compare values across categories in a bar chart format (e.g., sales by region comparing product types)</li>
<li><strong>Line Chart:</strong> Used for looking at a numeric value over time (e.g., revenue over time)</li>
<li><strong>Scatter Plot:</strong> Used to identify patterns between two continuous variables (e.g., profit vs. sales volume)</li>
<li><strong>Histogram:</strong> Used to show a distribution of data (e.g., Distribution of monthly revenue)</li>
<li><strong>Box-and-Whisper Plot:</strong> Used to compare distributions between categorical variables (e.g., distribution of revenue by region)</li>
<li><strong>Heat map: </strong>Used to visualize data in rows and columns as colors (e.g., revenue by marketing channel)</li>
<li><strong>Highlight table: </strong>Used to show data values with conditional color formatting (e.g., site traffic by marketing channel and year)</li>
<li><strong>Symbol Map:</strong> Used to show geographical data (e.g., Market size opportunity by state)</li>
<li><strong>Treemap:</strong> Used to show hierarchical data (e.g., Show how much revenue subdivisions generate relative to the whole department within an organization)</li>
<li><strong>Dual Combination:</strong> Used to show two visualizations within the same visualization (e.g., profit for a store each month as a bar chart with inventory over time as a line chart)</li>
</ul>
<h2>How to Customize Visualizations in Tableau</h2>
<p>Tableau provides a deep ability to filter, format, aggregate, customize, and highlight specific parts of your data visualizations</p>
<h3>Filtering data with highlights</h3>
<ul>
<li>Once you&rsquo;ve created a visual, click and drag your mouse over the specific portion you want to highlight</li>
<li>Once you let go, you will have the option to <em>Keep Only</em> or <em>Exclude</em> the data</li>
<li>Open the <em>Data</em> pane on the sidebar. Then, you can drag-and-drop a field into the filters card just to the left of the pane</li>
</ul>
<h3>Filtering data with filters</h3>
<ul>
<li>Open the <em>Data</em> pane on the left-hand side</li>
<li>Drag-and-drop a field you want to filter on and add it to the <em>Filters</em> card</li>
<li>Fill out in the modal how you would like your visuals to be filtered on the data</li>
</ul>
<h3>Aggregating data</h3>
<ul>
<li>Right-click on a measure field in the <em>Data</em> pane</li>
<li>Go down to <em>Default</em> properties, <em>Aggregation</em>, and select the aggregation you would like to use&nbsp;</li>
</ul>
<h3>Changing colors</h3>
<ul>
<li>Create a visualization by dragging fields into the <em>Rows</em> and <em>Columns</em> section at the top of the screen</li>
<li>Drag dimensions into the <em>Marks</em> field, specifically into the <em>Color</em> square</li>
<li>To change from the default colors, go to the upper-right corner of the color legend and select <em>Edit Colors</em>. This will bring up a dialog that allows you to select a different palette</li>
</ul>
<h3>Changing fonts</h3>
<ul>
<li>In the <em>Format</em> menu on the top ribbon, press on <em>Select Workbook</em>. This will replace the <em>Data</em> pane and allow you to make formatting decisions for the Workbook</li>
<li>From here, select the font, font size, and color</li>
</ul>
<h2>How to Create Dashboards in Tableau</h2>
<ol>
<li>Launch Tableau</li>
<li>In the <em>Connect</em> section under <em>To A File</em>, press on your desired file type</li>
<li>Select your file</li>
<li>Click the <em>New Sheet</em> at the bottom to create a new sheet</li>
<li>Create a visualization in the sheet by following the steps in the previous sections of this cheat sheet</li>
<li>Repeat steps 4 and 5 until you have created all the visualizations you want to include in your dashboard</li>
<li>Click the <em>New Dashboard</em> at the bottom of the screen</li>
<li>On the left-hand side, you will see all your created sheets. Drag sheets into the dashboard</li>
<li>Adjust the layout of your sheets by dragging and dropping your visualizations</li>
</ol>
<h2>How to Create Stories in Tableau</h2>
<ol>
<li>Click the <em>New Story</em> at the bottom of the screen</li>
<li>Change the size of the story to the desired size in the bottom left-hand corner of the screen under <em>Size</em></li>
<li>Edit the title of the story by renaming the story. To do this, right-click on the story sheet at the bottom and press <em>Rename</em></li>
<li>A story is made of story points, which lets you cycle through different visualizations and dashboards</li>
<li>To begin adding to the story, add a story point from the left-hand side. You can add a blank story point</li>
<li>To add a summary text to the story, click <em>Add a caption</em> and summarize the story point</li>
<li>Add as many story points as you would like to finalize your data story</li>
</ol>
<h2>Learn more about Tableau</h2>
<p>Here are a few extra Tableau resources to get you started:</p>
<ul>
<li><a href="https://www.datacamp.com/tracks/tableau-fundamentals">Tableau Fundamentals Skills track</a>&nbsp;</li>
<li><a href="https://www.datacamp.com/blog/5-tableau-tips-and-tricks-for-streamlining-your-workflow">5 Tableau Tips and Tricks for Streamlining Your Workflow</a></li>
<li><a href="https://www.datacamp.com/blog/all-about-tableau">All about Tableau</a></li>
</ul>
<p>Check out DataCamp's <a href="https://www.datacamp.com/courses/introduction-to-data-visualization-with-matplotlib">Introduction to Data Visualization with Matplotlib</a> course.</p>

In this Tableau Cheat Sheet, you'll get the download on creating your first visualization, top visualizations in Tableau, creating dashboards, stories, and more.

Tableau Cheat Sheet

In this data visualization cheat sheet, you'll learn about the most common data visualizations to employ, when to use them, and their most common use-cases. 

Data Visualization Cheat Sheet

In this Power BI Cheat Sheet, you'll get the download on creating your first visualization, top visualizations in Power BI, using DAX, and more.

Power BI Cheat Sheet

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

<h2 id="about-spacy">About spaCy</h2>
<p><a href="https://spacy.io">spaCy</a> is a free, open-source library for advanced Natural Language Processing (NLP) in Python. It's designed specifically for production use and helps you build applications that process and "understand" large volumes of text.</p>
<p>To learn more about spaCy, take my DataCamp course <a href="https://www.datacamp.com/courses/advanced-nlp-with-spacy">"Advanced NLP with spaCy"</a>. You can download the Cheat Sheet <a href="http://datacamp-community-prod.s3.amazonaws.com/b5685b85-c4de-4987-926d-b999d0f5a8b6">here</a>!</p>
<center><a href="http://datacamp-community-prod.s3.amazonaws.com/b5685b85-c4de-4987-926d-b999d0f5a8b6"><img src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1625838105/spaCy_Cheat_Sheet-_Advanced_NLP_in_Python_tdcgca.png" /></a></center>
<h2 id="getting-started">Getting started</h2>
<pre><code class="lang-python">$ pip install spacy
</code></pre>
<pre><code class="lang-python">import spacy
</code></pre>
<h2 id="statistical-models">Statistical models</h2>
<h3 id="download-statistical-models">Download statistical models</h3>
<p>Predict part-of-speech tags, dependency labels, named entities and more. <a href="https://spacy.io/models">See here</a> for available models.</p>
<pre><code class="lang-bash">$ python -m spacy download en_core_web_sm
</code></pre>
<h3 id="check-that-your-installed-models-are-up-to-date">Check that your installed models are up to date</h3>
<pre><code class="lang-bash">$ python -m spacy validate
</code></pre>
<h3 id="loading-statistical-models">Loading statistical models</h3>
<pre><code class="lang-python">import spacy
# Load the installed model "en_core_web_sm"
nlp = spacy.load("en_core_web_sm")
</code></pre>
<h2 id="documents-tokens-and-spans">Documents, tokens and spans</h2>
<h3 id="processing-text">Processing text</h3>
<p>Processing text with the <code>nlp</code> object returns a <code>Doc</code> object that holds all information about the tokens, their linguistic features and their relationships.</p>
<pre><code class="lang-python">doc = nlp("This is a text")
</code></pre>
<h3 id="accessing-token-attributes">Accessing token attributes</h3>
<pre><code class="lang-python">doc = nlp("This is a text")
# Token texts
[token.text for token in doc]
# ['This', 'is', 'a', 'text']
</code></pre>
<h2 id="spans">Spans</h2>
<h3 id="accessing-spans">Accessing spans</h3>
<p>Span indices are <strong>exclusive</strong>. So <code>doc[2:4]</code> is a span starting at token 2, up to &ndash; but not including! &ndash; token 4.</p>
<pre><code class="lang-python">doc = nlp("This is a text")
span = doc[2:4]
span.text
# 'a text'
</code></pre>
<h3 id="creating-a-span-manually">Creating a span manually</h3>
<pre><code class="lang-python"># Import the Span object
from spacy.tokens import Span
# Create a Doc object
doc = nlp("I live in New York")
# Span for "New York" with label GPE (geopolitical)
span = Span(doc, 3, 5, label="GPE")
span.text
# 'New York'
</code></pre>
<h2 id="linguistic-features">Linguistic features</h2>
<p>Attributes return label IDs. For string labels, use the attributes with an underscore. For example, <code>token.pos_</code>.</p>
<h2 id="part-of-speech-tags-predicted-by-statistical-model-">Part-of-speech tags (predicted by statistical model)</h2>
<pre><code class="lang-python">doc = nlp("This is a text.")
# Coarse-grained part-of-speech tags
[token.pos_ for token in doc]
# ['DET', 'VERB', 'DET', 'NOUN', 'PUNCT']
# Fine-grained part-of-speech tags
[token.tag_ for token in doc]
# ['DT', 'VBZ', 'DT', 'NN', '.']
</code></pre>
<h2 id="syntactic-dependencies-predicted-by-statistical-model-">Syntactic dependencies (predicted by statistical model)</h2>
<pre><code class="lang-python">doc = nlp("This is a text.")
# Dependency labels
[token.dep_ for token in doc]
# ['nsubj', 'ROOT', 'det', 'attr', 'punct']
# Syntactic head token (governor)
[token.head.text for token in doc]
# ['is', 'is', 'text', 'is', 'is']
</code></pre>
<h2 id="named-entities-predicted-by-statistical-model-">Named Entities (predicted by statistical model)</h2>
<pre><code class="lang-python">doc = nlp("Larry Page founded Google")
# Text and label of named entity span
[(ent.text, ent.label_) for ent in doc.ents]
# [('Larry Page', 'PERSON'), ('Google', 'ORG')]
</code></pre>
<h2 id="sentences-usually-needs-the-dependency-parser-">Sentences (usually needs the dependency parser)</h2>
<pre><code class="lang-python">doc = nlp("This a sentence. This is another one.")
# doc.sents is a generator that yields sentence spans
[sent.text for sent in doc.sents]
# ['This is a sentence.', 'This is another one.']
</code></pre>
<h2 id="base-noun-phrases-needs-the-tagger-and-parser-">Base noun phrases (needs the tagger and parser)</h2>
<pre><code class="lang-python">doc = nlp("I have a red car")
# doc.noun_chunks is a generator that yields spans
[chunk.text for chunk in doc.noun_chunks]
# ['I', 'a red car']
</code></pre>
<h2 id="label-explanations">Label explanations</h2>
<pre><code class="lang-python">spacy.explain("RB")
# 'adverb'
spacy.explain("GPE")
# 'Countries, cities, states'
</code></pre>
<h2 id="visualizing">Visualizing</h2>
<p>⚠️ If you're in a Jupyter notebook, use <code>displacy.render</code>. Otherwise, use <code>displacy.serve</code> to start a web server and show the visualization in your browser.</p>
<pre><code class="lang-python">from spacy import displacy
</code></pre>
<h3 id="visualize-dependencies">Visualize dependencies</h3>
<pre><code class="lang-python">doc = nlp("This is a sentence")
displacy.render(doc, style="dep")
</code></pre>
<p><img src="https://user-images.githubusercontent.com/13643239/52234132-38e76a00-28c1-11e9-82e6-e5d6b4a7f339.png" alt="displacy_dep" width="640" /></p>
<h3 id="visualize-named-entities">Visualize named entities</h3>
<pre><code class="lang-python">doc = nlp("Larry Page founded Google")
displacy.render(doc, style="ent")
</code></pre>
<p><img src="https://user-images.githubusercontent.com/13643239/52234151-443a9580-28c1-11e9-831a-9adee3ec87b1.png" alt="displacy_ent" width="422" /></p>
<h2 id="word-vectors-and-similarity">Word vectors and similarity</h2>
<p>⚠️ To use word vectors, you need to install the larger models ending in <code>md</code> or <code>lg</code> , for <code>example en_core_web_lg</code>.</p>
<h3 id="comparing-similarity">Comparing similarity</h3>
<pre><code class="lang-python">doc1 = nlp("I like cats")
doc2 = nlp("I like dogs")
# Compare 2 documents
doc1.similarity(doc2)
# Compare 2 tokens
doc1[2].similarity(doc2[2])
# Compare tokens and spans
doc1[0].similarity(doc2[1:3])
</code></pre>
<h3 id="accessing-word-vectors">Accessing word vectors</h3>
<pre><code class="lang-python"># Vector as a numpy array
doc = nlp("I like cats")
# The L2 norm of the token's vector
doc[2].vector
doc[2].vector_norm
</code></pre>
<h2 id="pipeline-components">Pipeline components</h2>
<p>Functions that take a <code>Doc</code> object, modify it and return it.</p>
<p><img src="https://user-images.githubusercontent.com/13643239/55229632-dbff9480-521d-11e9-8499-efb2a9c948db.png" alt="pipeline" width="682" /></p>
<h3 id="pipeline-information">Pipeline information</h3>
<pre><code class="lang-python">nlp = spacy.load("en_core_web_sm")
nlp.pipe_names
# ['tagger', 'parser', 'ner']
nlp.pipeline
# [('tagger', &lt;spacy.pipeline.Tagger&gt;),
# ('parser', &lt;spacy.pipeline.DependencyParser&gt;),
# ('ner', &lt;spacy.pipeline.EntityRecognizer&gt;)]
</code></pre>
<h3 id="custom-components">Custom components</h3>
<pre><code class="lang-python"># Function that modifies the doc and returns it
def custom_component(doc):
 print("Do something to the doc here!")
 return doc

# Add the component first in the pipeline
nlp.add_pipe(custom_component, first=True)
</code></pre>
<p>Components can be added <code>first</code>, <code>last</code> (default), or <code>before</code> or <code>after</code> an existing component.</p>
<h2 id="extension-attributes">Extension attributes</h2>
<p>Custom attributes that are registered on the global <code>Doc</code>, <code>Token</code> and <code>Span</code> classes and become available as <code>._</code>.</p>
<pre><code class="lang-python">from spacy.tokens import Doc, Token, Span
doc = nlp("The sky over New York is blue")
</code></pre>
<h3 id="attribute-extensions-with-default-value-">Attribute extensions (with default value)</h3>
<pre><code class="lang-python"># Register custom attribute on Token class
Token.set_extension("is_color", default=False)
# Overwrite extension attribute with default value
doc[6]._.is_color = True
</code></pre>
<h3 id="property-extensions-with-getter-setter-">Property extensions (with getter &amp; setter)</h3>
<pre><code class="lang-python"># Register custom attribute on Doc class
get_reversed = lambda doc: doc.text[::-1]
Doc.set_extension("reversed", getter=get_reversed)
# Compute value of extension attribute with getter
doc._.reversed
# 'eulb si kroY weN revo yks ehT'
</code></pre>
<h3 id="method-extensions-callable-method-">Method extensions (callable method)</h3>
<pre><code class="lang-python"># Register custom attribute on Span class
has_label = lambda span, label: span.label_ == label
Span.set_extension("has_label", method=has_label)
# Compute value of extension attribute with method
doc[3:5].has_label("GPE")
# True
</code></pre>
<h2 id="rule-based-matching">Rule-based matching</h2>
<h3 id="using-the-matcher">Using the Matcher</h3>
<pre><code class="lang-python"># Matcher is initialized with the shared vocab
from spacy.matcher import Matcher
# Each dict represents one token and its attributes
matcher = Matcher(nlp.vocab)
# Add with ID, optional callback and pattern(s)
pattern = [{"LOWER": "new"}, {"LOWER": "york"}]
matcher.add('CITIES', None, pattern)
# Match by calling the matcher on a Doc object
doc = nlp("I live in New York")
matches = matcher(doc)
# Matches are (match_id, start, end) tuples
for match_id, start, end in matches:
     # Get the matched span by slicing the Doc
     span = doc[start:end]
     print(span.text)
# 'New York'
</code></pre>
<h3 id="token-patterns">Token patterns</h3>
<pre><code class="lang-python"># "love cats", "loving cats", "loved cats"
pattern1 = [{"LEMMA": "love"}, {"LOWER": "cats"}]
# "10 people", "twenty people"
pattern2 = [{"LIKE_NUM": True}, {"TEXT": "people"}]
# "book", "a cat", "the sea" (noun + optional article)
pattern3 = [{"POS": "DET", "OP": "?"}, {"POS": "NOUN"}]
</code></pre>
<h3 id="operators-and-quantifiers">Operators and quantifiers</h3>
<p>Can be added to a token dict as the <code>"OP"</code> key.</p>
<div class="output_wrapper">
<table>
<thead>
<tr>
<th>OP</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>!</code></td>
<td>Negate pattern and match exactly 0 times.</td>
</tr>
<tr>
<td><code>?</code></td>
<td>Make pattern optional and match 0 or 1 times.</td>
</tr>
<tr>
<td><code>+</code></td>
<td>Require pattern to match 1 or more times.</td>
</tr>
<tr>
<td><code>*</code></td>
<td>Allow pattern to match 0 or more times.</td>
</tr>
</tbody>
</table>
</div>
<h2 id="glossary">spaCy Glossary</h2>
<div class="output_wrapper">
<table>
<thead>
<tr>
<th>Name</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>Tokenization</strong></td>
<td>Segmenting text into words, punctuation etc.</td>
</tr>
<tr>
<td><strong>Lemmatization</strong></td>
<td>Assigning the base forms of words, for example: "was" &rarr; "be" or "rats" &rarr; "rat".</td>
</tr>
<tr>
<td><strong>Sentence Boundary Detection</strong></td>
<td>Finding and segmenting individual sentences.</td>
</tr>
<tr>
<td><strong>Part-of-speech (POS) Tagging</strong></td>
<td>Assigning word types to tokens like verb or noun.</td>
</tr>
<tr>
<td><strong>Dependency Parsing</strong></td>
<td>Assigning syntactic dependency labels, describing the relations between individual tokens, like subject or object.</td>
</tr>
<tr>
<td><strong>Named Entity Recognition (NER)</strong></td>
<td>Labeling named "real-world" objects, like persons, companies or locations.</td>
</tr>
<tr>
<td><strong>Text Classification</strong></td>
<td>Assigning categories or labels to a whole document, or parts of a document.</td>
</tr>
<tr>
<td><strong>Statistical model</strong></td>
<td>Process for making predictions based on examples.</td>
</tr>
<tr>
<td><strong>Training</strong></td>
<td>Updating a statistical model with new examples.</td>
</tr>
</tbody>
</table>
</div>

Check out the first official spaCy cheat sheet! A handy two-page reference to the most important concepts and features.

spaCy Cheat Sheet: Advanced NLP in Python

<p>Apache Spark is generally known as a fast, general and open-source engine for big data processing, with built-in modules for streaming, SQL, machine learning and graph processing. It allows you to speed analytic applications up to 100 times faster compared to technologies on the market today. You can interface Spark with Python through "PySpark". This is the Spark Python API exposes the Spark programming model to Python.&nbsp;</p>
<p>Even though working with Spark will remind you in many ways of working with <a href="https://www.datacamp.com/community/tutorials/pandas-tutorial-dataframe-python/">Pandas DataFrames</a>, you'll also see that it can be tough getting familiar with all the functions that you can use to query, transform,&nbsp;inspect, ...&nbsp;your data. What's more, if you've never worked with any other programming language or if you're new to the field, it might be hard to distinguish between RDD operations.</p>
<p>Let's face it, <code>map()</code> and <code>flatMap()</code> are different enough, but it might still come as a challenge to decide which one you really need when you're faced with them in your analysis. Or what about other functions, like&nbsp;<code>reduce()</code> and <code>reduceByKey()</code>?&nbsp;</p>
<p><a href="http://datacamp-community-prod.s3.amazonaws.com/acfa4325-1d43-4542-8ce4-bea2d287db10" target="_blank" rel="noopener"><img style="width: 800px; height: 551px;" src="https://res.cloudinary.com/dyd911kmh/image/upload/f_auto,q_auto:best/v1625837623/PySpark_Cheat_Sheet-_Spark_in_Python_owornh.png" alt="PySpark cheat sheet" /></a></p>
<p>Even though the <a href="http://spark.apache.org/docs/latest/api/python/">documentation</a> is very elaborate, it never hurts to have a cheat sheet by your side, especially when you're just getting into it.</p>
<p>This PySpark cheat sheet covers the basics, from initializing Spark and loading your data, to retrieving RDD information, sorting, filtering and sampling your data. But that's not all. You'll also see that topics such as repartitioning, iterating, merging, saving your data and stopping the SparkContext are included in the cheat sheet.&nbsp;</p>
<p><strong>Note</strong> that the examples in the document take small data sets to illustrate the effect of specific functions on your data. In real life data analysis, you'll be using Spark to analyze big data.</p>
<p>Are you hungry for more? Don't miss our other Python cheat sheets for data science that cover topics such as&nbsp;<a href="https://www.datacamp.com/community/tutorials/python-data-science-cheat-sheet-basics/">Python basics</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/python-pandas-cheat-sheet/">Pandas</a>,&nbsp;<a href="https://www.datacamp.com/community/blog/pandas-cheat-sheet-python/">Pandas Data Wrangling</a>&nbsp;and much more!&nbsp;</p>
<p><img src="data:image/png;base64,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" /></p>
<p><strong>PySpark is the Spark Python API that exposes the Spark programming model to Python.</strong></p>
<h2><strong>Initializing Spark&nbsp;</strong></h2>
<h3><strong>SparkContext&nbsp;</strong></h3>
<pre class="language-python"><code>&gt;&gt;&gt; from pyspark import SparkContext
&gt;&gt;&gt; sc = SparkContext(master = 'local[2]')
</code></pre>
<h3><strong>Inspect SparkContext&nbsp;</strong></h3>
<pre class="language-python"><code>&gt;&gt;&gt; sc.version #Retrieve SparkContext version
&gt;&gt;&gt; sc.pythonVer #Retrieve Python version
&gt;&gt;&gt; sc.master #Master URL to connect to
&gt;&gt;&gt; str(sc.sparkHome) #Path where Spark is installed on worker nodes
&gt;&gt;&gt; str(sc.sparkUser()) #Retrieve name of the Spark User running SparkContext
&gt;&gt;&gt; sc.appName #Return application name
&gt;&gt;&gt; sc.applicationld #Retrieve application ID
&gt;&gt;&gt; sc.defaultParallelism #Return default level of parallelism
&gt;&gt;&gt; sc.defaultMinPartitions #Default minimum number of partitions for RDDs
</code></pre>
<h3>Configuration&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; from pyspark import SparkConf, SparkContext
&gt;&gt;&gt; conf = (SparkConf()
     .setMaster("local")
     .setAppName("My app")
     . set   ("spark. executor.memory",   "lg"))
&gt;&gt;&gt; sc = SparkContext(conf = conf)
</code></pre>
<h3>Using the Shell&nbsp;</h3>
<p>In the PySpark shell, a special interpreter-aware SparkContext is already created in the variable called sc.</p>
<pre class="language-python"><code>$ ./bin/spark-shell --master local[2]
$ ./bin/pyspark --master local[s] --py-files code.py</code></pre>
<p>Set which master the context connects to with the --master argument, and add Python .zip..egg or.py files to the</p>
<p>runtime path by passing a comma-separated list to &nbsp;--py-files.</p>
<h2><strong>Loading Data&nbsp;</strong></h2>
<h3><strong>Parallelized Collections&nbsp;</strong></h3>
<pre class="language-python"><code>&gt;&gt;&gt; rdd = sc.parallelize([('a',7),('a',2),('b',2)])
&gt;&gt;&gt; rdd2 = sc.parallelize([('a',2),('d',1),('b',1)])
&gt;&gt;&gt; rdd3 = sc.parallelize(range(100))
&gt;&gt;&gt; rdd = sc.parallelize([("a",["x","y","z"]),
               ("b" ["p","r,"])])

</code></pre>
<h3>External Data&nbsp;</h3>
<p>Read either one text file from HDFS, a local file system or any Hadoop-supported file system URI with textFile(), or read in a directory of text files with wholeTextFiles().&nbsp;</p>
<pre class="language-python"><code>&gt;&gt;&gt; textFile = sc.textFile("/my/directory/&bull;.txt")
&gt;&gt;&gt; textFile2 = sc.wholeTextFiles("/my/directory/")</code></pre>
<h2>Retrieving RDD Information&nbsp;</h2>
<h3>Basic Information&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; rdd.getNumPartitions() #List the number of partitions
&gt;&gt;&gt; rdd.count() #Count RDD instances 3
&gt;&gt;&gt; rdd.countByKey() #Count RDD instances by key
defaultdict(&lt;type 'int'&gt;,{'a':2,'b':1})
&gt;&gt;&gt; rdd.countByValue() #Count RDD instances by value
defaultdict(&lt;type 'int'&gt;,{('b',2):1,('a',2):1,('a',7):1})
&gt;&gt;&gt; rdd.collectAsMap() #Return (key,value) pairs as a dictionary
   {'a': 2, 'b': 2}
&gt;&gt;&gt; rdd3.sum() #Sum of RDD elements 4950
&gt;&gt;&gt; sc.parallelize([]).isEmpty() #Check whether RDD is empty
True
</code></pre>
<h3>Summary&nbsp;</h3>
<pre class="language-python"><code>&gt;&gt;&gt; rdd3.max() #Maximum value of RDD elements 
99
&gt;&gt;&gt; rdd3.min() #Minimum value of RDD elements
0
&gt;&gt;&gt; rdd3.mean() #Mean value of RDD elements 
49.5
&gt;&gt;&gt; rdd3.stdev() #Standard deviation of RDD elements 
28.866070047722118
&gt;&gt;&gt; rdd3.variance() #Compute variance of RDD elements 
833.25
&gt;&gt;&gt; rdd3.histogram(3) #Compute histogram by bins
([0,33,66,99],[33,33,34])
&gt;&gt;&gt; rdd3.stats() #Summary statistics (count, mean, stdev, max &amp; min)
</code></pre>
<h2>Applying Functions&nbsp;</h2>
<pre class="language-python"><code>#Apply a function to each RFD element
&gt;&gt;&gt; rdd.map(lambda x: x+(x[1],x[0])).collect()
[('a' ,7,7, 'a'),('a' ,2,2, 'a'), ('b' ,2,2, 'b')]
#Apply a function to each RDD element and flatten the result
&gt;&gt;&gt; rdd5 = rdd.flatMap(lambda x: x+(x[1],x[0]))
&gt;&gt;&gt; rdd5.collect()
['a',7 , 7 ,  'a' , 'a' , 2,  2,  'a', 'b', 2 , 2, 'b']
#Apply a flatMap function to each (key,value) pair of rdd4 without changing the keys
&gt;&gt;&gt; rdds.flatMapValues(lambda x: x).collect()
[('a', 'x'), ('a', 'y'), ('a', 'z'),('b', 'p'),('b', 'r')]
</code></pre>
<h2>Selecting Data</h2>
<p><strong>Getting</strong></p>
<pre class="language-python"><code>&gt;&gt;&gt; rdd.collect() #Return a list with all RDD elements 
[('a', 7), ('a', 2), ('b', 2)]
&gt;&gt;&gt; rdd.take(2) #Take first 2 RDD elements 
[('a', 7),  ('a', 2)]
&gt;&gt;&gt; rdd.first() #Take first RDD element
('a', 7)
&gt;&gt;&gt; rdd.top(2) #Take top 2 RDD elements 
[('b', 2), ('a', 7)]</code></pre>
<p><strong>Sampling</strong></p>
<pre class="language-python"><code>&gt;&gt;&gt; rdd3.sample(False, 0.15, 81).collect() #Return sampled subset of rdd3
     [3,4,27,31,40,41,42,43,60,76,79,80,86,97]</code></pre>
<p><strong>Filtering</strong></p>
<pre class="language-python"><code>&gt;&gt;&gt; rdd.filter(lambda x: "a" in x).collect() #Filter the RDD
[('a',7),('a',2)]
&gt;&gt;&gt; rdd5.distinct().collect() #Return distinct RDD values
['a' ,2, 'b',7]
&gt;&gt;&gt; rdd.keys().collect() #Return (key,value) RDD's keys
['a',  'a',  'b']</code></pre>
<h2>Iterating&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; def g (x): print(x)
&gt;&gt;&gt; rdd.foreach(g) #Apply a function to all RDD elements
('a', 7)
('b', 2)
('a', 2)
</code></pre>
<h2>Reshaping Data&nbsp;</h2>
<p><strong>Reducing</strong></p>
<pre class="language-python"><code>&gt;&gt;&gt; rdd.reduceByKey(lambda x,y : x+y).collect() #Merge the rdd values for each key
[('a',9),('b',2)]
&gt;&gt;&gt; rdd.reduce(lambda a, b: a+ b) #Merge the rdd values
('a', 7, 'a' , 2 , 'b' , 2)</code></pre>
<p><strong>&nbsp;</strong></p>
<p><strong>Grouping by</strong></p>
<pre class="language-python"><code>&gt;&gt;&gt; rdd3.groupBy(lambda x: x % 2) #Return RDD of grouped values
          .mapValues(list)
          .collect()
&gt;&gt;&gt; rdd.groupByKey() #Group rdd by key
          .mapValues(list)
          .collect() 
[('a',[7,2]),('b',[2])]</code></pre>
<p><strong>Aggregating</strong></p>
<pre class="language-python"><code>&gt;&gt; seqOp = (lambda x,y: (x[0]+y,x[1]+1))
&gt;&gt;&gt; combOp = (lambda x,y:(x[0]+y[0],x[1]+y[1]))
#Aggregate RDD elements of each partition and then the results
&gt;&gt;&gt; rdd3.aggregate((0,0),seqOp,combOp) 
(4950,100)
#Aggregate values of each RDD key
&gt;&gt;&gt; rdd.aggregateByKey((0,0),seqop,combop).collect() 
     [('a',(9,2)), ('b',(2,1))]
#Aggregate the elements of each partition, and then the results
&gt;&gt;&gt; rdd3.fold(0,add)
     4950
#Merge the values for each key
&gt;&gt;&gt; rdd.foldByKey(0, add).collect()
[('a' ,9), ('b' ,2)]
#Create tuples of RDD elements by applying a function
&gt;&gt;&gt; rdd3.keyBy(lambda x: x+x).collect()</code></pre>
<h2>Mathematical Operations&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt;&gt; rdd.subtract(rdd2).collect() #Return each rdd value not contained in rdd2
[('b' ,2), ('a' ,7)]
#Return each (key,value) pair of rdd2 with no matching key in rdd
&gt;&gt;&gt; rdd2.subtractByKey(rdd).collect()
[('d', 1)1
&gt;&gt;&gt;rdd.cartesian(rdd2).collect() #Return the Cartesian product of rdd and rdd2
</code></pre>
<h2>Sort&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; rdd2.sortBy(lambda x: x[1]).collect() #Sort RDD by given function
[('d',1),('b',1),('a',2)]
&gt;&gt;&gt; rdd2.sortByKey().collect() #Sort (key, value) ROD by key
[('a' ,2), ('b' ,1), ('d' ,1)]
</code></pre>
<h2>Repartitioning&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; rdd.repartition(4) #New RDD with 4 partitions
&gt;&gt;&gt; rdd.coalesce(1) #Decrease the number of partitions in the RDD to 1
</code></pre>
<h2>Saving&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; rdd.saveAsTextFile("rdd.txt")
&gt;&gt;&gt; rdd.saveAsHadoopFile("hdfs:// namenodehost/parent/child",
               'org.apache.hadoop.mapred.TextOutputFormat')
</code></pre>
<h2>Stopping SparkContext&nbsp;</h2>
<pre class="language-python"><code>&gt;&gt;&gt; sc.stop()</code></pre>
<h2>Execution&nbsp;</h2>
<pre class="language-python"><code>$ ./bin/spark-submit examples/src/main/python/pi.py
</code></pre>
<h2>Learn more about PySpark</h2>
<p><a href="https://www.datacamp.com/courses/introduction-to-pyspark">Introduction to PySpark</a></p>
<p><a href="https://www.datacamp.com/courses/big-data-fundamentals-with-pyspark">Big Data Fundamentals with PySpark</a></p>
<p><a href="https://www.datacamp.com/courses/cleaning-data-with-pyspark">Cleaning Data with PySpark</a></p>
<p><a href="https://www.datacamp.com/courses/feature-engineering-with-pyspark">Feature Engineering with PySpark</a></p>
<p><a href="https://www.datacamp.com/courses/machine-learning-with-pyspark">Machine Learning with PySpark</a></p>
<p><a href="https://www.datacamp.com/courses/recommendation-engines-in-pyspark">Building Recommendation Engines with PySpark</a></p>

This PySpark cheat sheet with code samples covers the basics like initializing Spark in Python, loading data, sorting, and repartitioning.

PySpark Cheat Sheet: Spark in Python 

<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

Download quick points of reference from our cheat sheets blog. There's everything from advanced NLP in Python & the Bokeh library to data.table in R & more.

Data Science Cheat Sheets