ENDS 12/4: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


Learn the basics of creating, loading, and selecting data in Pandas using DataFrames.

Creating, Loading, and Selecting Data with Pandas

You can also combine multiple logical statements, as long as each statement is in parentheses.

For instance, suppose we wanted to select all rows where the customer's age was under 30 *or* the customer's name was "Martha Jones":

<div class="narrative-table-container"> <div class="narrative-table-scroll">

|name|address|phone|age|
|-|-|-|-|
|Martha Jones|123 Main St.|234-567-8910|28|
|Rose Tyler|456 Maple Ave.|212-867-5309|22|
|Donna Noble|789 Broadway|949-123-4567|35|
|Amy Pond|98 West End Ave.|646-555-1234|29|
|Clara Oswald|54 Columbus Ave.|714-225-1957|31|
|...| | | | |

</div></div>
<br>

We could use the following code:
```py
df[(df.age < 30) |
   (df.name == 'Martha Jones')]
```
In Python, `|` means "or" and `&` means "and".

Select Rows with Logic II

Selecting Multiple Rows

When we select a subset of a DataFrame using logic, we end up with non-consecutive indices.  This is inelegant and makes it hard to use `.iloc()`.

We can fix this using the method `.reset_index()`.  For example, here is a DataFrame called `df` with non-consecutive indices:

<div class="narrative-table-container"> <div class="narrative-table-scroll">

|          | First Name | Last Name|
|--------|-----------------|---------------|
|0        | John              | Smith        |
|4        | Jane               | Doe          |
| 7       | Joe                  | Schmo      |

</div></div>
<br>

If we use the command `df.reset_index()`, we get a new DataFrame with a new set of indices:

<div class="narrative-table-container"> <div class="narrative-table-scroll">

| | index| First Name | Last Name|
|-|--------|-----------------|---------------|
|0|0        | John              | Smith        |
|1|4        | Jane               | Doe          |
|2| 7       | Joe                  | Schmo      |

</div></div>
<br>

Note that the old indices have been moved into a new column called `'index'`.  Unless you need those values for something special, it's probably better to use the keyword `drop=True` so that you don't end up with that extra column.  If we run the command `df.reset_index(drop=True)`, we get a new DataFrame that looks like this:

<div class="narrative-table-container"> <div class="narrative-table-scroll">

|          | First Name | Last Name|
|--------|-----------------|---------------|
|0        | John              | Smith        |
|1        | Jane               | Doe          |
| 2       | Joe                  | Schmo      |

</div></div>
<br>

Using `.reset_index()` will return a new DataFrame, but we usually just want to modify our existing DataFrame. If we use the keyword `inplace=True` we can just modify our existing DataFrame.




Setting indices

You've completed the lesson!  You've just learned the basics of working with a single table in Pandas, including:
- Create a table from scratch
- Loading data from another file
- Selecting certain rows or columns of a table

Let's practice what you've learned.


Review

When we load a new DataFrame from a CSV, we want to know what it looks like.

If it's a small DataFrame, you can display it by typing `print(df)`.

If it's a larger DataFrame, it's helpful to be able to inspect a few items without having to look at the entire DataFrame.

The method `.head()` gives the first 5 rows of a DataFrame.  If you want to see more rows, you can pass in the positional argument `n`.  For example,  `df.head(10)` would show the first 10 rows.

The method **`df.info()`** gives some statistics for each column.

Inspect a DataFrame

We now know how to create our own DataFrame.  However, most of the time, we'll be working with datasets that already exist.  One of the most common formats for big datasets is the *CSV*.

*CSV (comma separated values)* is a text-only spreadsheet format.  You can find CSVs in lots of places:
* Online datasets (here's an example from <a href="https://catalog.data.gov/dataset?res_format=CSV" target="_blank" rel="noopener noreferrer">data.gov</a>)
* Export from Excel or Google Sheets
* Export from SQL


The first row of a CSV contains column headings. All subsequent rows contain values. Each column heading and each variable is separated by a comma:

```
column1,column2,column3
value1,value2,value3
```
That example CSV represents the following table:

<div class="narrative-table-container">

|column1|column2|column3|
|-----------|------------|------------|
|value1    |value2    |value3    |

</div>

Comma Separated Variables (CSV)

Pandas is a Python module for working with tabular data (i.e., data in a table with rows and columns). Tabular data has a lot of the same functionality as SQL or Excel, but Pandas adds the power of Python.

In order to get access to the Pandas module, we'll need to install the module and then import it into a Python file. To learn how to install Python for data analysis on your personal computer, please refer to the following Codecademy resources:

* <a href="https://www.codecademy.com/articles/introducing-jupyter-notebook" target="_blank">Introducing Jupyter Notebook</a>
* <a href="https://www.codecademy.com/articles/setting-up-jupyter-notebook" target="_blank">Setting Up Jupyter Notebook</a>
* <a href="https://www.codecademy.com/articles/getting-started-with-jupyter" target="_blank">Getting Started with Jupyter Notebook</a>

Otherwise, let's move on! The `pandas` module is usually imported at the top of a Python file under the alias `pd`.

```py
import pandas as pd
```

If we need to access the `pandas` module, we can do so by operating on `pd`.

In this lesson, you’ll learn the basics of working with a single table in Pandas, such as:
- Create a table from scratch
- Loading data from another file
- Selecting certain rows or columns of a table

----
**Note:** In order for Codecademy to properly display data from Pandas, we need to import another special library:
```py
import codecademylib3
```
When you're on Codecademy.com, we'll always provide this import for you at the top of `script.py`.

When you're not on Codecademy.com, you won't need it.

Importing the Pandas Module

You can select a subset of a DataFrame by using logical statements:
```py
df[df.MyColumnName == desired_column_value]
```
We have a large DataFrame with information about our customers.  A few of the many rows look like this:

<div class="narrative-table-container">
<div class="narrative-table-scroll">

|name|address|phone|age|
|-|-|-|-|
|Martha Jones|123 Main St.|234-567-8910|28|
|Rose Tyler|456 Maple Ave.|212-867-5309|22|
|Donna Noble|789 Broadway|949-123-4567|35|
|Amy Pond|98 West End Ave.|646-555-1234|29|
|Clara Oswald|54 Columbus Ave.|714-225-1957|31|
|...|...|...|...|...|

</div>
</div>
<br>

Suppose we want to select all rows where the customer's age is 30.  We would use:
```py
df[df.age == 30]
```
In Python, `==` is how we test if a value is exactly equal to another value.

We can use other logical statements, such as:
* Greater Than, `>` &mdash; Here, we select all rows where the customer's age is greater than 30:
```py
df[df.age > 30]
```
* Less Than, `<` &mdash;
Here, we select all rows where the customer's age is less than 30:
```py
df[df.age < 30]
```
* Not Equal, `!=` &mdash;
This snippet selects all rows where the customer's name is *not* `Clara Oswald`:
```py
df[df.name != 'Clara Oswald']
```

Select Rows with Logic I

Suppose we want to select the rows where the customer's name is either "Martha Jones", "Rose Tyler" or "Amy Pond".

<div class="narrative-table-container">
<div class="narrative-table-scroll">

|name|address|phone|age|
|-|-|-|-|
|Martha Jones|123 Main St.|234-567-8910|28|
|Rose Tyler|456 Maple Ave.|212-867-5309|22|
|Donna Noble|789 Broadway|949-123-4567|35|
|Amy Pond|98 West End Ave.|646-555-1234|29|
|Clara Oswald|54 Columbus Ave.|714-225-1957|31|
|...|...|...|...|...|

</div>
</div>
<br>

We could use the `isin` command to check that `df.name` is one of a list of values:
```py
df[df.name.isin(['Martha Jones',
     'Rose Tyler',
     'Amy Pond'])]
```

Select Rows with Logic III

Selecting Multiple Columns

When you have data in a CSV, you can load it into a DataFrame in Pandas using `.read_csv()`:

```py
pd.read_csv('my-csv-file.csv')
```

In the example above, the `.read_csv()` method is called. The CSV file called `my-csv-file` is passed in as an argument.

We can also save data to a CSV, using `.to_csv()`.

```py
df.to_csv('new-csv-file.csv')
```

In the example above, the `.to_csv()` method is called on `df` (which represents a DataFrame object).  The name of the CSV file is passed in as an argument (`new-csv-file.csv`). By default, this method will save the CSV file in your current directory.

Loading and Saving CSVs

You can also add data using lists. 

For example, you can pass in a list of lists, where each one represents a row of data.  Use the keyword argument `columns` to pass a list of column names.  

```py
df2 = pd.DataFrame([
    ['John Smith', '123 Main St.', 34],
    ['Jane Doe', '456 Maple Ave.', 28],
    ['Joe Schmo', '789 Broadway', 51]
    ],
    columns=['name', 'address', 'age'])
```

This command produces a DataFrame `df2` that looks like this:

<div class="narrative-table-container">

|name|address|age|
|-|-|-|
|John Smith|123 Main St.|34|
|Jane Doe|456 Maple Ave.|28|
|Joe Schmo|789 Broadway|51|

</div>
<br>

In this example, we were able to control the ordering of the columns because we used lists.

Create a DataFrame II

Let's revisit our `orders` from ShoeFly.com:

<div class="narrative-table-container">

|id|first_name|last_name|email|shoe_type|shoe_material|shoe_color|
| --- | --- | --- | --- | --- | --- | --- |
|54791|Rebecca|Lindsay|RebeccaLindsay57@hotmail.com|clogs|faux-leather|black|
|53450|Emily|James|EmilyJames25@gmail.com|ballet flats|faux-leather|navy|
|91987|Joyce|Waller|Joyce.Waller@gmail.com|sandals|fabric|black|
|14437|Justin|Erickson|Justin.Erickson@outlook.com|clogs|faux-leather|red|
|...| | | | | | | |

</div>

<br>

Maybe our Customer Service department has just received a message from Joyce Waller, so we want to know exactly what she ordered. We want to select this single row of data.

DataFrames are zero-indexed, meaning that we start with the 0th row and count up from there. Joyce Waller's order is the 2nd row.

We select it using the following command:

```py
orders.iloc[2]
```

When we select a single row, the result is a *Series* (just like when we select a single column).

Select Rows

A DataFrame is an object that stores data as rows and columns. You can think of a DataFrame as a spreadsheet or as a SQL table. You can manually create a DataFrame or fill it with data from a CSV, an Excel spreadsheet, or a SQL query.

DataFrames have rows and columns. Each column has a name, which is a string. Each row has an index, which is an integer. DataFrames can contain many different data types: strings, ints, floats, tuples, etc.

You can pass in a dictionary to `pd.DataFrame()`. Each key is a column name and each value is a list of column values.  The columns must all be the same length or you will get an error.  Here’s an example:

```py
df1 = pd.DataFrame({
    'name': ['John Smith', 'Jane Doe', 'Joe Schmo'],
    'address': ['123 Main St.', '456 Maple Ave.', '789 Broadway'],
    'age': [34, 28, 51]
})
```

This command creates a DataFrame called `df1` that looks like this:

<div class="narrative-table-container"> <div class="narrative-table-scroll">

|name|address|age|
|-|-|-|
|John Smith|123 Main St.|34|
|Jane Doe|456 Maple Ave.|28|
|Joe Schmo|789 Broadway|51|

</div>
</div>

Create a DataFrame I

Now we know how to create and load data. Let's select parts of those datasets that are interesting or important to our analyses.

Suppose you have the DataFrame called `customers`, which contains the ages of your customers: 
<div class='narrative-table-container'>

|name|age|
|-|-|
|Rebecca Erikson|35|
|Thomas Roberson|28|
|Diane Ochoa|42|
|...|...|

</div>
<br>

Perhaps you want to take the average or plot a histogram of the ages.  In order to do either of these tasks, you'd need to select the column.

There are two possible syntaxes for selecting all values from a column:
1. Select the column as if you were selecting a value from a dictionary using a key. In our example, we would type `customers['age']` to select the ages.
2. If the name of a column follows all of the rules for a variable name (doesn't start with a number, doesn't contain spaces or special characters, etc.), then you can select it using the following notation: `df.MySecondColumn`.  In our example, we would type `customers.age`.

---
When we select a single column, the result is called a *Series*.