Pandas Index & Slice

Question 1

data[‘b’]

returns ‘b’

Answer 1

Like a dictionary, the Series object provides a mapping from a collection of keys to a collection of values:

Question 2

‘a’ in data
data.keys()
list(data.items())

Answer 2

We can also use dictionary-like Python expressions and methods to examine the keys/indices and values:

Question 3

data[‘e’] = 1.25

Answer 3

Series objects can even be modified with a dictionary-like syntax. Just as you can extend a dictionary by assigning to a new key, you can extend a Series by assigning to a new index value:

Question 4

# slicing by explicit index
data['a':'c']

# slicing by implicit integer index
data[0:2]

# masking
data[(data > 0.3) &amp; (data < 0.8)]

# fancy indexing
data[['a', 'e']]

Answer 4

A Series builds on this dictionary-like interface and provides array-style item selection via the same basic mechanisms as NumPy arrays – that is, slices, masking, and fancy indexing. Examples of these are as follows:

Question 5

data. loc[1]

data. loc[1:3]

Answer 5

Pandas provides some special indexer attributes that explicitly expose certain indexing schemes. These are not functional methods, but attributes that expose a particular slicing interface to the data in the Series.

First, the loc attribute allows indexing and slicing that always references the explicit index:

Question 6

data. iloc[1]

data. iloc[1:3]

Answer 6

The iloc attribute allows indexing and slicing that always references the implicit Python-style index:

Question 7

data[‘area’]

data.area

Answer 7

The individual Series that make up the columns of the DataFrame can be accessed via dictionary-style indexing of the column name:

Question 8

data[‘density’] = data[‘pop’] / data[‘area’]

data

Answer 8

Like with the Series objects discussed earlier, this dictionary-style syntax can also be used to modify the object, in this case adding a new column:

Question 9

data.T

Answer 9

many familiar array-like observations can be done on the DataFrame itself. For example, we can transpose the full DataFrame to swap rows and columns:

Question 10

data.iloc[:3, :2]

Answer 10

Here Pandas again uses the loc, iloc, and ix indexers mentioned earlier. Using the iloc indexer, we can index the underlying array as if it is a simple NumPy array (using the implicit Python-style index), but the DataFrame index and column labels are maintained in the result:

Question 11

data.loc[:’Illinois’, :’pop’]

Answer 11

Similarly, using the loc indexer we can index the underlying data in an array-like style but using the explicit index and column names:

Question 12

data.loc[data.density > 100, [‘pop’, ‘density’]]

Answer 12

Any of the familiar NumPy-style data access patterns can be used within these indexers. For example, in the loc indexer we can combine masking and fancy indexing as in the following:

Question 13

data[‘Florida’:’Illinois’]
data[1:3]
data[data.density > 100]

Answer 13

First, while indexing refers to columns, slicing refers to rows:

direct masking operations are also interpreted row-wise rather than column-wise: