Indexing and Selecting Data — pandas 0.16.2 documentation (original) (raw)

The axis labeling information in pandas objects serves many purposes:

In this section, we will focus on the final point: namely, how to slice, dice, and generally get and set subsets of pandas objects. The primary focus will be on Series and DataFrame as they have received more development attention in this area. Expect more work to be invested in higher-dimensional data structures (including Panel) in the future, especially in label-based advanced indexing.

Note

The Python and NumPy indexing operators [] and attribute operator .provide quick and easy access to pandas data structures across a wide range of use cases. This makes interactive work intuitive, as there’s little new to learn if you already know how to deal with Python dictionaries and NumPy arrays. However, since the type of the data to be accessed isn’t known in advance, directly using standard operators has some optimization limits. For production code, we recommended that you take advantage of the optimized pandas data access methods exposed in this chapter.

Warning

Whether a copy or a reference is returned for a setting operation, may depend on the context. This is sometimes called chained assignment and should be avoided. See Returning a View versus Copy

Warning

In 0.15.0 Index has internally been refactored to no longer subclass ndarraybut instead subclass PandasObject, similarly to the rest of the pandas objects. This should be a transparent change with only very limited API implications (See the Internal Refactoring)

See the MultiIndex / Advanced Indexing for MultiIndex and more advanced indexing documentation.

See the cookbook for some advanced strategies

Different Choices for Indexing

New in version 0.11.0.

Object selection has had a number of user-requested additions in order to support more explicit location based indexing. pandas now supports three types of multi-axis indexing.

Getting values from an object with multi-axes selection uses the following notation (using .loc as an example, but applies to .iloc and .ix as well). Any of the axes accessors may be the null slice :. Axes left out of the specification are assumed to be :. (e.g. p.loc['a'] is equiv top.loc['a', :, :])

Object Type Indexers
Series s.loc[indexer]
DataFrame df.loc[row_indexer,column_indexer]
Panel p.loc[item_indexer,major_indexer,minor_indexer]

Deprecations

Beginning with version 0.11.0, it’s recommended that you transition away from the following methods as they may be deprecated in future versions.

See the section Selection by Position for substitutes.

Basics

As mentioned when introducing the data structures in the last section, the primary function of indexing with [] (a.k.a. __getitem__for those familiar with implementing class behavior in Python) is selecting out lower-dimensional slices. Thus,

Object Type Selection Return Value Type
Series series[label] scalar value
DataFrame frame[colname] Series corresponding to colname
Panel panel[itemname] DataFrame corresponing to the itemname

Here we construct a simple time series data set to use for illustrating the indexing functionality:

In [1]: dates = date_range('1/1/2000', periods=8)

In [2]: df = DataFrame(randn(8, 4), index=dates, columns=['A', 'B', 'C', 'D'])

In [3]: df Out[3]: A B C D 2000-01-01 0.469112 -0.282863 -1.509059 -1.135632 2000-01-02 1.212112 -0.173215 0.119209 -1.044236 2000-01-03 -0.861849 -2.104569 -0.494929 1.071804 2000-01-04 0.721555 -0.706771 -1.039575 0.271860 2000-01-05 -0.424972 0.567020 0.276232 -1.087401 2000-01-06 -0.673690 0.113648 -1.478427 0.524988 2000-01-07 0.404705 0.577046 -1.715002 -1.039268 2000-01-08 -0.370647 -1.157892 -1.344312 0.844885

In [4]: panel = Panel({'one' : df, 'two' : df - df.mean()})

In [5]: panel Out[5]: <class 'pandas.core.panel.Panel'> Dimensions: 2 (items) x 8 (major_axis) x 4 (minor_axis) Items axis: one to two Major_axis axis: 2000-01-01 00:00:00 to 2000-01-08 00:00:00 Minor_axis axis: A to D

Note

None of the indexing functionality is time series specific unless specifically stated.

Thus, as per above, we have the most basic indexing using []:

In [6]: s = df['A']

In [7]: s[dates[5]] Out[7]: -0.67368970808837025

In [8]: panel['two'] Out[8]: A B C D 2000-01-01 0.409571 0.113086 -0.610826 -0.936507 2000-01-02 1.152571 0.222735 1.017442 -0.845111 2000-01-03 -0.921390 -1.708620 0.403304 1.270929 2000-01-04 0.662014 -0.310822 -0.141342 0.470985 2000-01-05 -0.484513 0.962970 1.174465 -0.888276 2000-01-06 -0.733231 0.509598 -0.580194 0.724113 2000-01-07 0.345164 0.972995 -0.816769 -0.840143 2000-01-08 -0.430188 -0.761943 -0.446079 1.044010

You can pass a list of columns to [] to select columns in that order. If a column is not contained in the DataFrame, an exception will be raised. Multiple columns can also be set in this manner:

In [9]: df Out[9]: A B C D 2000-01-01 0.469112 -0.282863 -1.509059 -1.135632 2000-01-02 1.212112 -0.173215 0.119209 -1.044236 2000-01-03 -0.861849 -2.104569 -0.494929 1.071804 2000-01-04 0.721555 -0.706771 -1.039575 0.271860 2000-01-05 -0.424972 0.567020 0.276232 -1.087401 2000-01-06 -0.673690 0.113648 -1.478427 0.524988 2000-01-07 0.404705 0.577046 -1.715002 -1.039268 2000-01-08 -0.370647 -1.157892 -1.344312 0.844885

In [10]: df[['B', 'A']] = df[['A', 'B']]

In [11]: df Out[11]: A B C D 2000-01-01 -0.282863 0.469112 -1.509059 -1.135632 2000-01-02 -0.173215 1.212112 0.119209 -1.044236 2000-01-03 -2.104569 -0.861849 -0.494929 1.071804 2000-01-04 -0.706771 0.721555 -1.039575 0.271860 2000-01-05 0.567020 -0.424972 0.276232 -1.087401 2000-01-06 0.113648 -0.673690 -1.478427 0.524988 2000-01-07 0.577046 0.404705 -1.715002 -1.039268 2000-01-08 -1.157892 -0.370647 -1.344312 0.844885

You may find this useful for applying a transform (in-place) to a subset of the columns.

Attribute Access

You may access an index on a Series, column on a DataFrame, and a item on a Panel directly as an attribute:

In [12]: sa = Series([1,2,3],index=list('abc'))

In [13]: dfa = df.copy()

In [14]: sa.b Out[14]: 2

In [15]: dfa.A Out[15]: 2000-01-01 -0.282863 2000-01-02 -0.173215 2000-01-03 -2.104569 2000-01-04 -0.706771 2000-01-05 0.567020 2000-01-06 0.113648 2000-01-07 0.577046 2000-01-08 -1.157892 Freq: D, Name: A, dtype: float64

In [16]: panel.one Out[16]: A B C D 2000-01-01 0.469112 -0.282863 -1.509059 -1.135632 2000-01-02 1.212112 -0.173215 0.119209 -1.044236 2000-01-03 -0.861849 -2.104569 -0.494929 1.071804 2000-01-04 0.721555 -0.706771 -1.039575 0.271860 2000-01-05 -0.424972 0.567020 0.276232 -1.087401 2000-01-06 -0.673690 0.113648 -1.478427 0.524988 2000-01-07 0.404705 0.577046 -1.715002 -1.039268 2000-01-08 -0.370647 -1.157892 -1.344312 0.844885

You can use attribute access to modify an existing element of a Series or column of a DataFrame, but be careful; if you try to use attribute access to create a new column, it fails silently, creating a new attribute rather than a new column.

In [17]: sa.a = 5

In [18]: sa Out[18]: a 5 b 2 c 3 dtype: int64

In [19]: dfa.A = list(range(len(dfa.index))) # ok if A already exists

In [20]: dfa Out[20]: A B C D 2000-01-01 0 0.469112 -1.509059 -1.135632 2000-01-02 1 1.212112 0.119209 -1.044236 2000-01-03 2 -0.861849 -0.494929 1.071804 2000-01-04 3 0.721555 -1.039575 0.271860 2000-01-05 4 -0.424972 0.276232 -1.087401 2000-01-06 5 -0.673690 -1.478427 0.524988 2000-01-07 6 0.404705 -1.715002 -1.039268 2000-01-08 7 -0.370647 -1.344312 0.844885

In [21]: dfa['A'] = list(range(len(dfa.index))) # use this form to create a new column

In [22]: dfa Out[22]: A B C D 2000-01-01 0 0.469112 -1.509059 -1.135632 2000-01-02 1 1.212112 0.119209 -1.044236 2000-01-03 2 -0.861849 -0.494929 1.071804 2000-01-04 3 0.721555 -1.039575 0.271860 2000-01-05 4 -0.424972 0.276232 -1.087401 2000-01-06 5 -0.673690 -1.478427 0.524988 2000-01-07 6 0.404705 -1.715002 -1.039268 2000-01-08 7 -0.370647 -1.344312 0.844885

Warning

If you are using the IPython environment, you may also use tab-completion to see these accessible attributes.

You can also assign a dict to a row of a DataFrame:

In [23]: x = pd.DataFrame({'x': [1, 2, 3], 'y': [3, 4, 5]})

In [24]: x.iloc[1] = dict(x=9, y=99)

In [25]: x Out[25]: x y 0 1 3 1 9 99 2 3 5

Slicing ranges

The most robust and consistent way of slicing ranges along arbitrary axes is described in the Selection by Position section detailing the .iloc method. For now, we explain the semantics of slicing using the [] operator.

With Series, the syntax works exactly as with an ndarray, returning a slice of the values and the corresponding labels:

In [26]: s[:5] Out[26]: 2000-01-01 -0.282863 2000-01-02 -0.173215 2000-01-03 -2.104569 2000-01-04 -0.706771 2000-01-05 0.567020 Freq: D, Name: A, dtype: float64

In [27]: s[::2] Out[27]: 2000-01-01 -0.282863 2000-01-03 -2.104569 2000-01-05 0.567020 2000-01-07 0.577046 Freq: 2D, Name: A, dtype: float64

In [28]: s[::-1] Out[28]: 2000-01-08 -1.157892 2000-01-07 0.577046 2000-01-06 0.113648 2000-01-05 0.567020 2000-01-04 -0.706771 2000-01-03 -2.104569 2000-01-02 -0.173215 2000-01-01 -0.282863 Freq: -1D, Name: A, dtype: float64

Note that setting works as well:

In [29]: s2 = s.copy()

In [30]: s2[:5] = 0

In [31]: s2 Out[31]: 2000-01-01 0.000000 2000-01-02 0.000000 2000-01-03 0.000000 2000-01-04 0.000000 2000-01-05 0.000000 2000-01-06 0.113648 2000-01-07 0.577046 2000-01-08 -1.157892 Freq: D, Name: A, dtype: float64

With DataFrame, slicing inside of [] slices the rows. This is provided largely as a convenience since it is such a common operation.

In [32]: df[:3] Out[32]: A B C D 2000-01-01 -0.282863 0.469112 -1.509059 -1.135632 2000-01-02 -0.173215 1.212112 0.119209 -1.044236 2000-01-03 -2.104569 -0.861849 -0.494929 1.071804

In [33]: df[::-1] Out[33]: A B C D 2000-01-08 -1.157892 -0.370647 -1.344312 0.844885 2000-01-07 0.577046 0.404705 -1.715002 -1.039268 2000-01-06 0.113648 -0.673690 -1.478427 0.524988 2000-01-05 0.567020 -0.424972 0.276232 -1.087401 2000-01-04 -0.706771 0.721555 -1.039575 0.271860 2000-01-03 -2.104569 -0.861849 -0.494929 1.071804 2000-01-02 -0.173215 1.212112 0.119209 -1.044236 2000-01-01 -0.282863 0.469112 -1.509059 -1.135632

Selection By Label

Warning

Whether a copy or a reference is returned for a setting operation, may depend on the context. This is sometimes called chained assignment and should be avoided. See Returning a View versus Copy

Warning

.loc

is strict when you present slicers that are not compatible (or convertible) with the index type. For example using integers in a

DatetimeIndex

. These will raise a

TypeError

.

In [34]: dfl = DataFrame(np.random.randn(5,4), columns=list('ABCD'), index=date_range('20130101',periods=5))

In [35]: dfl Out[35]: A B C D 2013-01-01 1.075770 -0.109050 1.643563 -1.469388 2013-01-02 0.357021 -0.674600 -1.776904 -0.968914 2013-01-03 -1.294524 0.413738 0.276662 -0.472035 2013-01-04 -0.013960 -0.362543 -0.006154 -0.923061 2013-01-05 0.895717 0.805244 -1.206412 2.565646

In [4]: dfl.loc[2:3] TypeError: cannot do slice indexing on <class 'pandas.tseries.index.DatetimeIndex'> with these indexers [2] of <type 'int'>

String likes in slicing can be convertible to the type of the index and lead to natural slicing.

In [36]: dfl.loc['20130102':'20130104'] Out[36]: A B C D 2013-01-02 0.357021 -0.674600 -1.776904 -0.968914 2013-01-03 -1.294524 0.413738 0.276662 -0.472035 2013-01-04 -0.013960 -0.362543 -0.006154 -0.923061

pandas provides a suite of methods in order to have purely label based indexing. This is a strict inclusion based protocol.At least 1 of the labels for which you ask, must be in the index or a KeyError will be raised! When slicing, the start bound is included, AND the stop bound is included. Integers are valid labels, but they refer to the label and not the position.

The .loc attribute is the primary access method. The following are valid inputs:

In [37]: s1 = Series(np.random.randn(6),index=list('abcdef'))

In [38]: s1 Out[38]: a 1.431256 b 1.340309 c -1.170299 d -0.226169 e 0.410835 f 0.813850 dtype: float64

In [39]: s1.loc['c':] Out[39]: c -1.170299 d -0.226169 e 0.410835 f 0.813850 dtype: float64

In [40]: s1.loc['b'] Out[40]: 1.3403088497993827

Note that setting works as well:

In [41]: s1.loc['c':] = 0

In [42]: s1 Out[42]: a 1.431256 b 1.340309 c 0.000000 d 0.000000 e 0.000000 f 0.000000 dtype: float64

With a DataFrame

In [43]: df1 = DataFrame(np.random.randn(6,4), ....: index=list('abcdef'), ....: columns=list('ABCD')) ....:

In [44]: df1 Out[44]: A B C D a 0.132003 -0.827317 -0.076467 -1.187678 b 1.130127 -1.436737 -1.413681 1.607920 c 1.024180 0.569605 0.875906 -2.211372 d 0.974466 -2.006747 -0.410001 -0.078638 e 0.545952 -1.219217 -1.226825 0.769804 f -1.281247 -0.727707 -0.121306 -0.097883

In [45]: df1.loc[['a','b','d'],:] Out[45]: A B C D a 0.132003 -0.827317 -0.076467 -1.187678 b 1.130127 -1.436737 -1.413681 1.607920 d 0.974466 -2.006747 -0.410001 -0.078638

Accessing via label slices

In [46]: df1.loc['d':,'A':'C'] Out[46]: A B C d 0.974466 -2.006747 -0.410001 e 0.545952 -1.219217 -1.226825 f -1.281247 -0.727707 -0.121306

For getting a cross section using a label (equiv to df.xs('a'))

In [47]: df1.loc['a'] Out[47]: A 0.132003 B -0.827317 C -0.076467 D -1.187678 Name: a, dtype: float64

For getting values with a boolean array

In [48]: df1.loc['a']>0 Out[48]: A True B False C False D False Name: a, dtype: bool

In [49]: df1.loc[:,df1.loc['a']>0] Out[49]: A a 0.132003 b 1.130127 c 1.024180 d 0.974466 e 0.545952 f -1.281247

For getting a value explicitly (equiv to deprecated df.get_value('a','A'))

this is also equivalent to df1.at['a','A']

In [50]: df1.loc['a','A'] Out[50]: 0.13200317033032927

Selection By Position

Warning

Whether a copy or a reference is returned for a setting operation, may depend on the context. This is sometimes called chained assignment and should be avoided. See Returning a View versus Copy

pandas provides a suite of methods in order to get purely integer based indexing. The semantics follow closely python and numpy slicing. These are 0-based indexing. When slicing, the start bounds is included, while the upper bound is excluded. Trying to use a non-integer, even a valid label will raise a IndexError.

The .iloc attribute is the primary access method. The following are valid inputs:

In [51]: s1 = Series(np.random.randn(5),index=list(range(0,10,2)))

In [52]: s1 Out[52]: 0 0.695775 2 0.341734 4 0.959726 6 -1.110336 8 -0.619976 dtype: float64

In [53]: s1.iloc[:3] Out[53]: 0 0.695775 2 0.341734 4 0.959726 dtype: float64

In [54]: s1.iloc[3] Out[54]: -1.1103361028911667

Note that setting works as well:

In [55]: s1.iloc[:3] = 0

In [56]: s1 Out[56]: 0 0.000000 2 0.000000 4 0.000000 6 -1.110336 8 -0.619976 dtype: float64

With a DataFrame

In [57]: df1 = DataFrame(np.random.randn(6,4), ....: index=list(range(0,12,2)), ....: columns=list(range(0,8,2))) ....:

In [58]: df1 Out[58]: 0 2 4 6 0 0.149748 -0.732339 0.687738 0.176444 2 0.403310 -0.154951 0.301624 -2.179861 4 -1.369849 -0.954208 1.462696 -1.743161 6 -0.826591 -0.345352 1.314232 0.690579 8 0.995761 2.396780 0.014871 3.357427 10 -0.317441 -1.236269 0.896171 -0.487602

Select via integer slicing

In [59]: df1.iloc[:3] Out[59]: 0 2 4 6 0 0.149748 -0.732339 0.687738 0.176444 2 0.403310 -0.154951 0.301624 -2.179861 4 -1.369849 -0.954208 1.462696 -1.743161

In [60]: df1.iloc[1:5,2:4] Out[60]: 4 6 2 0.301624 -2.179861 4 1.462696 -1.743161 6 1.314232 0.690579 8 0.014871 3.357427

Select via integer list

In [61]: df1.iloc[[1,3,5],[1,3]] Out[61]: 2 6 2 -0.154951 -2.179861 6 -0.345352 0.690579 10 -1.236269 -0.487602

For slicing rows explicitly (equiv to deprecated df.irow(slice(1,3))).

In [62]: df1.iloc[1:3,:] Out[62]: 0 2 4 6 2 0.403310 -0.154951 0.301624 -2.179861 4 -1.369849 -0.954208 1.462696 -1.743161

For slicing columns explicitly (equiv to deprecated df.icol(slice(1,3))).

In [63]: df1.iloc[:,1:3] Out[63]: 2 4 0 -0.732339 0.687738 2 -0.154951 0.301624 4 -0.954208 1.462696 6 -0.345352 1.314232 8 2.396780 0.014871 10 -1.236269 0.896171

For getting a scalar via integer position (equiv to deprecated df.get_value(1,1))

this is also equivalent to df1.iat[1,1]

In [64]: df1.iloc[1,1] Out[64]: -0.15495077442490321

For getting a cross section using an integer position (equiv to df.xs(1))

In [65]: df1.iloc[1] Out[65]: 0 0.403310 2 -0.154951 4 0.301624 6 -2.179861 Name: 2, dtype: float64

Out of range slice indexes are handled gracefully just as in Python/Numpy.

these are allowed in python/numpy.

Only works in Pandas starting from v0.14.0.

In [66]: x = list('abcdef')

In [67]: x Out[67]: ['a', 'b', 'c', 'd', 'e', 'f']

In [68]: x[4:10] Out[68]: ['e', 'f']

In [69]: x[8:10] Out[69]: []

In [70]: s = Series(x)

In [71]: s Out[71]: 0 a 1 b 2 c 3 d 4 e 5 f dtype: object

In [72]: s.iloc[4:10] Out[72]: 4 e 5 f dtype: object

In [73]: s.iloc[8:10] Out[73]: Series([], dtype: object)

Note

Prior to v0.14.0, iloc would not accept out of bounds indexers for slices, e.g. a value that exceeds the length of the object being indexed.

Note that this could result in an empty axis (e.g. an empty DataFrame being returned)

In [74]: dfl = DataFrame(np.random.randn(5,2),columns=list('AB'))

In [75]: dfl Out[75]: A B 0 -0.082240 -2.182937 1 0.380396 0.084844 2 0.432390 1.519970 3 -0.493662 0.600178 4 0.274230 0.132885

In [76]: dfl.iloc[:,2:3] Out[76]: Empty DataFrame Columns: [] Index: [0, 1, 2, 3, 4]

In [77]: dfl.iloc[:,1:3] Out[77]: B 0 -2.182937 1 0.084844 2 1.519970 3 0.600178 4 0.132885

In [78]: dfl.iloc[4:6] Out[78]: A B 4 0.27423 0.132885

A single indexer that is out of bounds will raise an IndexError. A list of indexers where any element is out of bounds will raise anIndexError

dfl.iloc[[4,5,6]] IndexError: positional indexers are out-of-bounds

dfl.iloc[:,4] IndexError: single positional indexer is out-of-bounds

Selecting Random Samples

A random selection of rows or columns from a Series, DataFrame, or Panel with the sample() method. The method will sample rows by default, and accepts a specific number of rows/columns to return, or a fraction of rows.

In [79]: s = Series([0,1,2,3,4,5])

When no arguments are passed, returns 1 row.

In [80]: s.sample() Out[80]: 5 5 dtype: int64

One may specify either a number of rows:

In [81]: s.sample(n=3) Out[81]: 1 1 5 5 2 2 dtype: int64

Or a fraction of the rows:

In [82]: s.sample(frac=0.5) Out[82]: 4 4 5 5 1 1 dtype: int64

By default, sample will return each row at most once, but one can also sample with replacement using the replace option:

In [83]: s = Series([0,1,2,3,4,5])

Without replacement (default):

In [84]: s.sample(n=6, replace=False) Out[84]: 4 4 1 1 3 3 5 5 0 0 2 2 dtype: int64

With replacement:

In [85]: s.sample(n=6, replace=True) Out[85]: 2 2 0 0 3 3 2 2 4 4 4 4 dtype: int64

By default, each row has an equal probability of being selected, but if you want rows to have different probabilities, you can pass the sample function sampling weights asweights. These weights can be a list, a numpy array, or a Series, but they must be of the same length as the object you are sampling. Missing values will be treated as a weight of zero, and inf values are not allowed. If weights do not sum to 1, they will be re-normalized by dividing all weights by the sum of the weights. For example:

In [86]: s = Series([0,1,2,3,4,5])

In [87]: example_weights = [0, 0, 0.2, 0.2, 0.2, 0.4]

In [88]: s.sample(n=3, weights=example_weights) Out[88]: 2 2 5 5 4 4 dtype: int64

Weights will be re-normalized automatically

In [89]: example_weights2 = [0.5, 0, 0, 0, 0, 0]

In [90]: s.sample(n=1, weights=example_weights2) Out[90]: 0 0 dtype: int64

When applied to a DataFrame, you can use a column of the DataFrame as sampling weights (provided you are sampling rows and not columns) by simply passing the name of the column as a string.

In [91]: df2 = DataFrame({'col1':[9,8,7,6], 'weight_column':[0.5, 0.4, 0.1, 0]})

In [92]: df2.sample(n = 3, weights = 'weight_column') Out[92]: col1 weight_column 0 9 0.5 1 8 0.4 2 7 0.1

sample also allows users to sample columns instead of rows using the axis argument.

In [93]: df3 = DataFrame({'col1':[1,2,3], 'col2':[2,3,4]})

In [94]: df3.sample(n=1, axis=1) Out[94]: col1 0 1 1 2 2 3

Finally, one can also set a seed for sample‘s random number generator using the random_state argument, which will accept either an integer (as a seed) or a numpy RandomState object.

In [95]: df4 = DataFrame({'col1':[1,2,3], 'col2':[2,3,4]})

With a given seed, the sample will always draw the same rows.

In [96]: df4.sample(n=2, random_state=2) Out[96]: col1 col2 2 3 4 1 2 3

In [97]: df4.sample(n=2, random_state=2) Out[97]: col1 col2 2 3 4 1 2 3

Setting With Enlargement

New in version 0.13.

The .loc/.ix/[] operations can perform enlargement when setting a non-existant key for that axis.

In the Series case this is effectively an appending operation

In [98]: se = Series([1,2,3])

In [99]: se Out[99]: 0 1 1 2 2 3 dtype: int64

In [100]: se[5] = 5.

In [101]: se Out[101]: 0 1 1 2 2 3 5 5 dtype: float64

A DataFrame can be enlarged on either axis via .loc

In [102]: dfi = DataFrame(np.arange(6).reshape(3,2), .....: columns=['A','B']) .....:

In [103]: dfi Out[103]: A B 0 0 1 1 2 3 2 4 5

In [104]: dfi.loc[:,'C'] = dfi.loc[:,'A']

In [105]: dfi Out[105]: A B C 0 0 1 0 1 2 3 2 2 4 5 4

This is like an append operation on the DataFrame.

In [106]: dfi.loc[3] = 5

In [107]: dfi Out[107]: A B C 0 0 1 0 1 2 3 2 2 4 5 4 3 5 5 5

Fast scalar value getting and setting

Since indexing with [] must handle a lot of cases (single-label access, slicing, boolean indexing, etc.), it has a bit of overhead in order to figure out what you’re asking for. If you only want to access a scalar value, the fastest way is to use the at and iat methods, which are implemented on all of the data structures.

Similarly to loc, at provides label based scalar lookups, while, iat provides integer based lookups analogously to iloc

In [108]: s.iat[5] Out[108]: 5

In [109]: df.at[dates[5], 'A'] Out[109]: 0.11364840968888545

In [110]: df.iat[3, 0] Out[110]: -0.70677113363008437

You can also set using these same indexers.

In [111]: df.at[dates[5], 'E'] = 7

In [112]: df.iat[3, 0] = 7

at may enlarge the object in-place as above if the indexer is missing.

In [113]: df.at[dates[-1]+1, 0] = 7

In [114]: df Out[114]: A B C D E 0 2000-01-01 -0.282863 0.469112 -1.509059 -1.135632 NaN NaN 2000-01-02 -0.173215 1.212112 0.119209 -1.044236 NaN NaN 2000-01-03 -2.104569 -0.861849 -0.494929 1.071804 NaN NaN 2000-01-04 7.000000 0.721555 -1.039575 0.271860 NaN NaN 2000-01-05 0.567020 -0.424972 0.276232 -1.087401 NaN NaN 2000-01-06 0.113648 -0.673690 -1.478427 0.524988 7 NaN 2000-01-07 0.577046 0.404705 -1.715002 -1.039268 NaN NaN 2000-01-08 -1.157892 -0.370647 -1.344312 0.844885 NaN NaN 2000-01-09 NaN NaN NaN NaN NaN 7

Boolean indexing

Another common operation is the use of boolean vectors to filter the data. The operators are: | for or, & for and, and ~ for not. These must be grouped by using parentheses.

Using a boolean vector to index a Series works exactly as in a numpy ndarray:

In [115]: s = Series(range(-3, 4))

In [116]: s Out[116]: 0 -3 1 -2 2 -1 3 0 4 1 5 2 6 3 dtype: int32

In [117]: s[s > 0] Out[117]: 4 1 5 2 6 3 dtype: int32

In [118]: s[(s < -1) | (s > 0.5)] Out[118]: 0 -3 1 -2 4 1 5 2 6 3 dtype: int32

In [119]: s[~(s < 0)] Out[119]: 3 0 4 1 5 2 6 3 dtype: int32

You may select rows from a DataFrame using a boolean vector the same length as the DataFrame’s index (for example, something derived from one of the columns of the DataFrame):

In [120]: df[df['A'] > 0] Out[120]: A B C D E 0 2000-01-04 7.000000 0.721555 -1.039575 0.271860 NaN NaN 2000-01-05 0.567020 -0.424972 0.276232 -1.087401 NaN NaN 2000-01-06 0.113648 -0.673690 -1.478427 0.524988 7 NaN 2000-01-07 0.577046 0.404705 -1.715002 -1.039268 NaN NaN

List comprehensions and map method of Series can also be used to produce more complex criteria:

In [121]: df2 = DataFrame({'a' : ['one', 'one', 'two', 'three', 'two', 'one', 'six'], .....: 'b' : ['x', 'y', 'y', 'x', 'y', 'x', 'x'], .....: 'c' : randn(7)}) .....:

only want 'two' or 'three'

In [122]: criterion = df2['a'].map(lambda x: x.startswith('t'))

In [123]: df2[criterion] Out[123]: a b c 2 two y 1.450520 3 three x 0.206053 4 two y -0.251905

equivalent but slower

In [124]: df2[[x.startswith('t') for x in df2['a']]] Out[124]: a b c 2 two y 1.450520 3 three x 0.206053 4 two y -0.251905

Multiple criteria

In [125]: df2[criterion & (df2['b'] == 'x')] Out[125]: a b c 3 three x 0.206053

Note, with the choice methods Selection by Label, Selection by Position, and Advanced Indexing you may select along more than one axis using boolean vectors combined with other indexing expressions.

In [126]: df2.loc[criterion & (df2['b'] == 'x'),'b':'c'] Out[126]: b c 3 x 0.206053

Indexing with isin

Consider the isin method of Series, which returns a boolean vector that is true wherever the Series elements exist in the passed list. This allows you to select rows where one or more columns have values you want:

In [127]: s = Series(np.arange(5),index=np.arange(5)[::-1],dtype='int64')

In [128]: s Out[128]: 4 0 3 1 2 2 1 3 0 4 dtype: int64

In [129]: s.isin([2, 4, 6]) Out[129]: 4 False 3 False 2 True 1 False 0 True dtype: bool

In [130]: s[s.isin([2, 4, 6])] Out[130]: 2 2 0 4 dtype: int64

The same method is available for Index objects and is useful for the cases when you don’t know which of the sought labels are in fact present:

In [131]: s[s.index.isin([2, 4, 6])] Out[131]: 4 0 2 2 dtype: int64

compare it to the following

In [132]: s[[2, 4, 6]] Out[132]: 2 2 4 0 6 NaN dtype: float64

In addition to that, MultiIndex allows selecting a separate level to use in the membership check:

In [133]: s_mi = Series(np.arange(6), .....: index=pd.MultiIndex.from_product([[0, 1], ['a', 'b', 'c']])) .....:

In [134]: s_mi Out[134]: 0 a 0 b 1 c 2 1 a 3 b 4 c 5 dtype: int32

In [135]: s_mi.iloc[s_mi.index.isin([(1, 'a'), (2, 'b'), (0, 'c')])] Out[135]: 0 c 2 1 a 3 dtype: int32

In [136]: s_mi.iloc[s_mi.index.isin(['a', 'c', 'e'], level=1)] Out[136]: 0 a 0 c 2 1 a 3 c 5 dtype: int32

DataFrame also has an isin method. When calling isin, pass a set of values as either an array or dict. If values is an array, isin returns a DataFrame of booleans that is the same shape as the original DataFrame, with True wherever the element is in the sequence of values.

In [137]: df = DataFrame({'vals': [1, 2, 3, 4], 'ids': ['a', 'b', 'f', 'n'], .....: 'ids2': ['a', 'n', 'c', 'n']}) .....:

In [138]: values = ['a', 'b', 1, 3]

In [139]: df.isin(values) Out[139]: ids ids2 vals 0 True True True 1 True False False 2 False False True 3 False False False

Oftentimes you’ll want to match certain values with certain columns. Just make values a dict where the key is the column, and the value is a list of items you want to check for.

In [140]: values = {'ids': ['a', 'b'], 'vals': [1, 3]}

In [141]: df.isin(values) Out[141]: ids ids2 vals 0 True False True 1 True False False 2 False False True 3 False False False

Combine DataFrame’s isin with the any() and all() methods to quickly select subsets of your data that meet a given criteria. To select a row where each column meets its own criterion:

In [142]: values = {'ids': ['a', 'b'], 'ids2': ['a', 'c'], 'vals': [1, 3]}

In [143]: row_mask = df.isin(values).all(1)

In [144]: df[row_mask] Out[144]: ids ids2 vals 0 a a 1

The where() Method and Masking

Selecting values from a Series with a boolean vector generally returns a subset of the data. To guarantee that selection output has the same shape as the original data, you can use the where method in Series and DataFrame.

To return only the selected rows

In [145]: s[s > 0] Out[145]: 3 1 2 2 1 3 0 4 dtype: int64

To return a Series of the same shape as the original

In [146]: s.where(s > 0) Out[146]: 4 NaN 3 1 2 2 1 3 0 4 dtype: float64

Selecting values from a DataFrame with a boolean criterion now also preserves input data shape. where is used under the hood as the implementation. Equivalent is df.where(df < 0)

In [147]: df[df < 0] Out[147]: A B C D 2000-01-01 NaN NaN -0.863838 NaN 2000-01-02 -1.048089 -0.025747 -0.988387 NaN 2000-01-03 NaN NaN NaN -0.055758 2000-01-04 NaN -0.489682 NaN -0.034571 2000-01-05 -2.484478 -0.281461 NaN NaN 2000-01-06 NaN -0.977349 NaN -0.064034 2000-01-07 -1.282782 NaN -1.071357 NaN 2000-01-08 NaN NaN NaN -0.744471

In addition, where takes an optional other argument for replacement of values where the condition is False, in the returned copy.

In [148]: df.where(df < 0, -df) Out[148]: A B C D 2000-01-01 -1.266143 -0.299368 -0.863838 -0.408204 2000-01-02 -1.048089 -0.025747 -0.988387 -0.094055 2000-01-03 -1.262731 -1.289997 -0.082423 -0.055758 2000-01-04 -0.536580 -0.489682 -0.369374 -0.034571 2000-01-05 -2.484478 -0.281461 -0.030711 -0.109121 2000-01-06 -1.126203 -0.977349 -1.474071 -0.064034 2000-01-07 -1.282782 -0.781836 -1.071357 -0.441153 2000-01-08 -2.353925 -0.583787 -0.221471 -0.744471

You may wish to set values based on some boolean criteria. This can be done intuitively like so:

In [149]: s2 = s.copy()

In [150]: s2[s2 < 0] = 0

In [151]: s2 Out[151]: 4 0 3 1 2 2 1 3 0 4 dtype: int64

In [152]: df2 = df.copy()

In [153]: df2[df2 < 0] = 0

In [154]: df2 Out[154]: A B C D 2000-01-01 1.266143 0.299368 0.000000 0.408204 2000-01-02 0.000000 0.000000 0.000000 0.094055 2000-01-03 1.262731 1.289997 0.082423 0.000000 2000-01-04 0.536580 0.000000 0.369374 0.000000 2000-01-05 0.000000 0.000000 0.030711 0.109121 2000-01-06 1.126203 0.000000 1.474071 0.000000 2000-01-07 0.000000 0.781836 0.000000 0.441153 2000-01-08 2.353925 0.583787 0.221471 0.000000

By default, where returns a modified copy of the data. There is an optional parameter inplace so that the original data can be modified without creating a copy:

In [155]: df_orig = df.copy()

In [156]: df_orig.where(df > 0, -df, inplace=True);

In [157]: df_orig Out[157]: A B C D 2000-01-01 1.266143 0.299368 0.863838 0.408204 2000-01-02 1.048089 0.025747 0.988387 0.094055 2000-01-03 1.262731 1.289997 0.082423 0.055758 2000-01-04 0.536580 0.489682 0.369374 0.034571 2000-01-05 2.484478 0.281461 0.030711 0.109121 2000-01-06 1.126203 0.977349 1.474071 0.064034 2000-01-07 1.282782 0.781836 1.071357 0.441153 2000-01-08 2.353925 0.583787 0.221471 0.744471

alignment

Furthermore, where aligns the input boolean condition (ndarray or DataFrame), such that partial selection with setting is possible. This is analogous to partial setting via .ix (but on the contents rather than the axis labels)

In [158]: df2 = df.copy()

In [159]: df2[ df2[1:4] > 0 ] = 3

In [160]: df2 Out[160]: A B C D 2000-01-01 1.266143 0.299368 -0.863838 0.408204 2000-01-02 -1.048089 -0.025747 -0.988387 3.000000 2000-01-03 3.000000 3.000000 3.000000 -0.055758 2000-01-04 3.000000 -0.489682 3.000000 -0.034571 2000-01-05 -2.484478 -0.281461 0.030711 0.109121 2000-01-06 1.126203 -0.977349 1.474071 -0.064034 2000-01-07 -1.282782 0.781836 -1.071357 0.441153 2000-01-08 2.353925 0.583787 0.221471 -0.744471

New in version 0.13.

Where can also accept axis and level parameters to align the input when performing the where.

In [161]: df2 = df.copy()

In [162]: df2.where(df2>0,df2['A'],axis='index') Out[162]: A B C D 2000-01-01 1.266143 0.299368 1.266143 0.408204 2000-01-02 -1.048089 -1.048089 -1.048089 0.094055 2000-01-03 1.262731 1.289997 0.082423 1.262731 2000-01-04 0.536580 0.536580 0.369374 0.536580 2000-01-05 -2.484478 -2.484478 0.030711 0.109121 2000-01-06 1.126203 1.126203 1.474071 1.126203 2000-01-07 -1.282782 0.781836 -1.282782 0.441153 2000-01-08 2.353925 0.583787 0.221471 2.353925

This is equivalent (but faster than) the following.

In [163]: df2 = df.copy()

In [164]: df.apply(lambda x, y: x.where(x>0,y), y=df['A']) Out[164]: A B C D 2000-01-01 1.266143 0.299368 1.266143 0.408204 2000-01-02 -1.048089 -1.048089 -1.048089 0.094055 2000-01-03 1.262731 1.289997 0.082423 1.262731 2000-01-04 0.536580 0.536580 0.369374 0.536580 2000-01-05 -2.484478 -2.484478 0.030711 0.109121 2000-01-06 1.126203 1.126203 1.474071 1.126203 2000-01-07 -1.282782 0.781836 -1.282782 0.441153 2000-01-08 2.353925 0.583787 0.221471 2.353925

mask

mask is the inverse boolean operation of where.

In [165]: s.mask(s >= 0) Out[165]: 4 NaN 3 NaN 2 NaN 1 NaN 0 NaN dtype: float64

In [166]: df.mask(df >= 0) Out[166]: A B C D 2000-01-01 NaN NaN -0.863838 NaN 2000-01-02 -1.048089 -0.025747 -0.988387 NaN 2000-01-03 NaN NaN NaN -0.055758 2000-01-04 NaN -0.489682 NaN -0.034571 2000-01-05 -2.484478 -0.281461 NaN NaN 2000-01-06 NaN -0.977349 NaN -0.064034 2000-01-07 -1.282782 NaN -1.071357 NaN 2000-01-08 NaN NaN NaN -0.744471

The query() Method (Experimental)

New in version 0.13.

DataFrame objects have a query()method that allows selection using an expression.

You can get the value of the frame where column b has values between the values of columns a and c. For example:

In [167]: n = 10

In [168]: df = DataFrame(rand(n, 3), columns=list('abc'))

In [169]: df Out[169]: a b c 0 0.191519 0.622109 0.437728 1 0.785359 0.779976 0.272593 2 0.276464 0.801872 0.958139 3 0.875933 0.357817 0.500995 4 0.683463 0.712702 0.370251 5 0.561196 0.503083 0.013768 6 0.772827 0.882641 0.364886 7 0.615396 0.075381 0.368824 8 0.933140 0.651378 0.397203 9 0.788730 0.316836 0.568099

pure python

In [170]: df[(df.a < df.b) & (df.b < df.c)] Out[170]: a b c 2 0.276464 0.801872 0.958139

query

In [171]: df.query('(a < b) & (b < c)') Out[171]: a b c 2 0.276464 0.801872 0.958139

Do the same thing but fall back on a named index if there is no column with the name a.

In [172]: df = DataFrame(randint(n / 2, size=(n, 2)), columns=list('bc'))

In [173]: df.index.name = 'a'

In [174]: df Out[174]: b c a
0 2 3 1 4 1 2 4 0 3 4 1 4 1 4 5 1 4 6 0 1 7 0 0 8 4 0 9 4 2

In [175]: df.query('a < b and b < c') Out[175]: b c a
0 2 3

If instead you don’t want to or cannot name your index, you can use the nameindex in your query expression:

In [176]: df = DataFrame(randint(n, size=(n, 2)), columns=list('bc'))

In [177]: df Out[177]: b c 0 3 1 1 2 5 2 2 5 3 6 7 4 4 3 5 5 6 6 4 6 7 2 4 8 2 7 9 9 7

In [178]: df.query('index < b < c') Out[178]: b c 1 2 5 3 6 7

Note

If the name of your index overlaps with a column name, the column name is given precedence. For example,

In [179]: df = DataFrame({'a': randint(5, size=5)})

In [180]: df.index.name = 'a'

In [181]: df.query('a > 2') # uses the column 'a', not the index Out[181]: a a
0 3 3 4

You can still use the index in a query expression by using the special identifier ‘index’:

In [182]: df.query('index > 2') Out[182]: a a
3 4 4 1

If for some reason you have a column named index, then you can refer to the index as ilevel_0 as well, but at this point you should consider renaming your columns to something less ambiguous.

MultiIndex query() Syntax

You can also use the levels of a DataFrame with aMultiIndex as if they were columns in the frame:

In [183]: import pandas.util.testing as tm

In [184]: n = 10

In [185]: colors = tm.choice(['red', 'green'], size=n)

In [186]: foods = tm.choice(['eggs', 'ham'], size=n)

In [187]: colors Out[187]: array(['red', 'green', 'red', 'green', 'red', 'green', 'red', 'green', 'green', 'green'], dtype='|S5')

In [188]: foods Out[188]: array(['ham', 'eggs', 'ham', 'ham', 'ham', 'eggs', 'eggs', 'eggs', 'ham', 'eggs'], dtype='|S4')

In [189]: index = MultiIndex.from_arrays([colors, foods], names=['color', 'food'])

In [190]: df = DataFrame(randn(n, 2), index=index)

In [191]: df Out[191]: 0 1 color food
red ham 0.157622 -0.293555 green eggs 0.111560 0.597679 red ham -1.270093 0.120949 green ham -0.193898 1.804172 red ham -0.234694 0.939908 green eggs -0.171520 -0.153055 red eggs -0.363095 -0.067318 green eggs 1.444721 0.325771 ham -0.855732 -0.697595 eggs -0.276134 -1.258759

In [192]: df.query('color == "red"') Out[192]: 0 1 color food
red ham 0.157622 -0.293555 ham -1.270093 0.120949 ham -0.234694 0.939908 eggs -0.363095 -0.067318

If the levels of the MultiIndex are unnamed, you can refer to them using special names:

In [193]: df.index.names = [None, None]

In [194]: df Out[194]: 0 1 red ham 0.157622 -0.293555 green eggs 0.111560 0.597679 red ham -1.270093 0.120949 green ham -0.193898 1.804172 red ham -0.234694 0.939908 green eggs -0.171520 -0.153055 red eggs -0.363095 -0.067318 green eggs 1.444721 0.325771 ham -0.855732 -0.697595 eggs -0.276134 -1.258759

In [195]: df.query('ilevel_0 == "red"') Out[195]: 0 1 red ham 0.157622 -0.293555 ham -1.270093 0.120949 ham -0.234694 0.939908 eggs -0.363095 -0.067318

The convention is ilevel_0, which means “index level 0” for the 0th level of the index.

query() Use Cases

A use case for query() is when you have a collection ofDataFrame objects that have a subset of column names (or index levels/names) in common. You can pass the same query to both frames _without_having to specify which frame you’re interested in querying

In [196]: df = DataFrame(rand(n, 3), columns=list('abc'))

In [197]: df Out[197]: a b c 0 0.972113 0.046532 0.917354 1 0.158930 0.943383 0.763162 2 0.053878 0.254082 0.927973 3 0.838312 0.156925 0.690776 4 0.366946 0.937473 0.613365 5 0.699350 0.502946 0.711111 6 0.134386 0.828932 0.742846 7 0.457034 0.079103 0.373047 8 0.933636 0.418725 0.234212 9 0.572485 0.572111 0.416893

In [198]: df2 = DataFrame(rand(n + 2, 3), columns=df.columns)

In [199]: df2 Out[199]: a b c 0 0.625883 0.220362 0.622059 1 0.477672 0.974342 0.772985 2 0.027139 0.221022 0.120328 3 0.175274 0.429462 0.657769 4 0.565899 0.569035 0.654196 5 0.368558 0.952385 0.196770 6 0.849930 0.960458 0.381118 7 0.330936 0.260923 0.665491 8 0.181795 0.376800 0.014259 9 0.339135 0.401351 0.467574 10 0.652106 0.997192 0.517462 11 0.403612 0.058447 0.045196

In [200]: expr = '0.0 <= a <= c <= 0.5'

In [201]: map(lambda frame: frame.query(expr), [df, df2]) Out[201]: [Empty DataFrame Columns: [a, b, c] Index: [], a b c 2 0.027139 0.221022 0.120328 9 0.339135 0.401351 0.467574]

query() Python versus pandas Syntax Comparison

Full numpy-like syntax

In [202]: df = DataFrame(randint(n, size=(n, 3)), columns=list('abc'))

In [203]: df Out[203]: a b c 0 5 3 8 1 8 8 1 2 3 6 8 3 9 1 5 4 8 4 1 5 1 1 2 6 3 4 2 7 1 9 4 8 0 0 2 9 1 2 5

In [204]: df.query('(a < b) & (b < c)') Out[204]: a b c 2 3 6 8 9 1 2 5

In [205]: df[(df.a < df.b) & (df.b < df.c)] Out[205]: a b c 2 3 6 8 9 1 2 5

Slightly nicer by removing the parentheses (by binding making comparison operators bind tighter than &/|)

In [206]: df.query('a < b & b < c') Out[206]: a b c 2 3 6 8 9 1 2 5

Use English instead of symbols

In [207]: df.query('a < b and b < c') Out[207]: a b c 2 3 6 8 9 1 2 5

Pretty close to how you might write it on paper

In [208]: df.query('a < b < c') Out[208]: a b c 2 3 6 8 9 1 2 5

The in and not in operators

query() also supports special use of Python’s in andnot in comparison operators, providing a succinct syntax for calling theisin method of a Series or DataFrame.

get all rows where columns "a" and "b" have overlapping values

In [209]: df = DataFrame({'a': list('aabbccddeeff'), 'b': list('aaaabbbbcccc'), .....: 'c': randint(5, size=12), 'd': randint(9, size=12)}) .....:

In [210]: df Out[210]: a b c d 0 a a 1 7 1 a a 0 0 2 b a 0 2 3 b a 2 8 4 c b 0 4 5 c b 0 8 6 d b 1 3 7 d b 1 2 8 e c 4 4 9 e c 3 7 10 f c 2 7 11 f c 0 0

In [211]: df.query('a in b') Out[211]: a b c d 0 a a 1 7 1 a a 0 0 2 b a 0 2 3 b a 2 8 4 c b 0 4 5 c b 0 8

How you'd do it in pure Python

In [212]: df[df.a.isin(df.b)] Out[212]: a b c d 0 a a 1 7 1 a a 0 0 2 b a 0 2 3 b a 2 8 4 c b 0 4 5 c b 0 8

In [213]: df.query('a not in b') Out[213]: a b c d 6 d b 1 3 7 d b 1 2 8 e c 4 4 9 e c 3 7 10 f c 2 7 11 f c 0 0

pure Python

In [214]: df[~df.a.isin(df.b)] Out[214]: a b c d 6 d b 1 3 7 d b 1 2 8 e c 4 4 9 e c 3 7 10 f c 2 7 11 f c 0 0

You can combine this with other expressions for very succinct queries:

rows where cols a and b have overlapping values and col c's values are less than col d's

In [215]: df.query('a in b and c < d') Out[215]: a b c d 0 a a 1 7 2 b a 0 2 3 b a 2 8 4 c b 0 4 5 c b 0 8

pure Python

In [216]: df[df.b.isin(df.a) & (df.c < df.d)] Out[216]: a b c d 0 a a 1 7 2 b a 0 2 3 b a 2 8 4 c b 0 4 5 c b 0 8 6 d b 1 3 7 d b 1 2 9 e c 3 7 10 f c 2 7

Note

Note that in and not in are evaluated in Python, since numexprhas no equivalent of this operation. However, only the in/not in expression itself is evaluated in vanilla Python. For example, in the expression

df.query('a in b + c + d')

(b + c + d) is evaluated by numexpr and then the inoperation is evaluated in plain Python. In general, any operations that can be evaluated using numexpr will be.

Special use of the == operator with list objects

Comparing a list of values to a column using ==/!= works similarly to in/not in

In [217]: df.query('b == ["a", "b", "c"]') Out[217]: a b c d 0 a a 1 7 1 a a 0 0 2 b a 0 2 3 b a 2 8 4 c b 0 4 5 c b 0 8 6 d b 1 3 7 d b 1 2 8 e c 4 4 9 e c 3 7 10 f c 2 7 11 f c 0 0

pure Python

In [218]: df[df.b.isin(["a", "b", "c"])] Out[218]: a b c d 0 a a 1 7 1 a a 0 0 2 b a 0 2 3 b a 2 8 4 c b 0 4 5 c b 0 8 6 d b 1 3 7 d b 1 2 8 e c 4 4 9 e c 3 7 10 f c 2 7 11 f c 0 0

In [219]: df.query('c == [1, 2]') Out[219]: a b c d 0 a a 1 7 3 b a 2 8 6 d b 1 3 7 d b 1 2 10 f c 2 7

In [220]: df.query('c != [1, 2]') Out[220]: a b c d 1 a a 0 0 2 b a 0 2 4 c b 0 4 5 c b 0 8 8 e c 4 4 9 e c 3 7 11 f c 0 0

using in/not in

In [221]: df.query('[1, 2] in c') Out[221]: a b c d 0 a a 1 7 3 b a 2 8 6 d b 1 3 7 d b 1 2 10 f c 2 7

In [222]: df.query('[1, 2] not in c') Out[222]: a b c d 1 a a 0 0 2 b a 0 2 4 c b 0 4 5 c b 0 8 8 e c 4 4 9 e c 3 7 11 f c 0 0

pure Python

In [223]: df[df.c.isin([1, 2])] Out[223]: a b c d 0 a a 1 7 3 b a 2 8 6 d b 1 3 7 d b 1 2 10 f c 2 7

Boolean Operators

You can negate boolean expressions with the word not or the ~ operator.

In [224]: df = DataFrame(rand(n, 3), columns=list('abc'))

In [225]: df['bools'] = rand(len(df)) > 0.5

In [226]: df.query('~bools') Out[226]: a b c bools 0 0.395827 0.035597 0.171689 False 2 0.582329 0.898831 0.435002 False 3 0.078368 0.224708 0.697626 False 5 0.877177 0.221076 0.287379 False 6 0.993264 0.861585 0.108845 False

In [227]: df.query('not bools') Out[227]: a b c bools 0 0.395827 0.035597 0.171689 False 2 0.582329 0.898831 0.435002 False 3 0.078368 0.224708 0.697626 False 5 0.877177 0.221076 0.287379 False 6 0.993264 0.861585 0.108845 False

In [228]: df.query('not bools') == df[~df.bools] Out[228]: a b c bools 0 True True True True 2 True True True True 3 True True True True 5 True True True True 6 True True True True

Of course, expressions can be arbitrarily complex too

short query syntax

In [229]: shorter = df.query('a < b < c and (not bools) or bools > 2')

equivalent in pure Python

In [230]: longer = df[(df.a < df.b) & (df.b < df.c) & (~df.bools) | (df.bools > 2)]

In [231]: shorter Out[231]: a b c bools 3 0.078368 0.224708 0.697626 False

In [232]: longer Out[232]: a b c bools 3 0.078368 0.224708 0.697626 False

In [233]: shorter == longer Out[233]: a b c bools 3 True True True True

Performance of query()

DataFrame.query() using numexpr is slightly faster than Python for large frames

_images/query-perf.png

Note

You will only see the performance benefits of using the numexpr engine with DataFrame.query() if your frame has more than approximately 200,000 rows

_images/query-perf-small.png

This plot was created using a DataFrame with 3 columns each containing floating point values generated using numpy.random.randn().

Duplicate Data

If you want to identify and remove duplicate rows in a DataFrame, there are two methods that will help: duplicated and drop_duplicates. Each takes as an argument the columns to use to identify duplicated rows.

By default, the first observed row of a duplicate set is considered unique, but each method has a take_last parameter that indicates the last observed row should be taken instead.

In [234]: df2 = DataFrame({'a' : ['one', 'one', 'two', 'three', 'two', 'one', 'six'], .....: 'b' : ['x', 'y', 'y', 'x', 'y', 'x', 'x'], .....: 'c' : np.random.randn(7)}) .....:

In [235]: df2.duplicated(['a','b']) Out[235]: 0 False 1 False 2 False 3 False 4 True 5 True 6 False dtype: bool

In [236]: df2.drop_duplicates(['a','b']) Out[236]: a b c 0 one x 0.932713 1 one y -0.393510 2 two y -0.548454 3 three x 1.130736 6 six x -1.233298

In [237]: df2.drop_duplicates(['a','b'], take_last=True) Out[237]: a b c 1 one y -0.393510 3 three x 1.130736 4 two y -0.447217 5 one x 1.043921 6 six x -1.233298

An alternative way to drop duplicates on the index is .groupby(level=0) combined with first() or last().

In [238]: df3 = df2.set_index('b')

In [239]: df3 Out[239]: a c b
x one 0.932713 y one -0.393510 y two -0.548454 x three 1.130736 y two -0.447217 x one 1.043921 x six -1.233298

In [240]: df3.groupby(level=0).first() Out[240]: a c b
x one 0.932713 y one -0.393510

a bit more verbose

In [241]: df3.reset_index().drop_duplicates(subset='b', take_last=False).set_index('b') Out[241]: a c b
x one 0.932713 y one -0.393510

Dictionary-like get() method

Each of Series, DataFrame, and Panel have a get method which can return a default value.

In [242]: s = Series([1,2,3], index=['a','b','c'])

In [243]: s.get('a') # equivalent to s['a'] Out[243]: 1

In [244]: s.get('x', default=-1) Out[244]: -1

The select() Method

Another way to extract slices from an object is with the select method of Series, DataFrame, and Panel. This method should be used only when there is no more direct way. select takes a function which operates on labels alongaxis and returns a boolean. For instance:

In [245]: df.select(lambda x: x == 'A', axis=1) Out[245]: A 2000-01-01 0.454389 2000-01-02 0.036249 2000-01-03 0.378125 2000-01-04 0.075871 2000-01-05 -0.677097 2000-01-06 1.482845 2000-01-07 0.272681 2000-01-08 -0.459059

The lookup() Method

Sometimes you want to extract a set of values given a sequence of row labels and column labels, and the lookup method allows for this and returns a numpy array. For instance,

In [246]: dflookup = DataFrame(np.random.rand(20,4), columns = ['A','B','C','D'])

In [247]: dflookup.lookup(list(range(0,10,2)), ['B','C','A','B','D']) Out[247]: array([ 0.012 , 0.3551, 0.3261, 0.4702, 0.3107])

Index objects

The pandas Index class and its subclasses can be viewed as implementing an ordered multiset. Duplicates are allowed. However, if you try to convert an Index object with duplicate entries into aset, an exception will be raised.

Index also provides the infrastructure necessary for lookups, data alignment, and reindexing. The easiest way to create anIndex directly is to pass a list or other sequence toIndex:

In [248]: index = Index(['e', 'd', 'a', 'b'])

In [249]: index Out[249]: Index([u'e', u'd', u'a', u'b'], dtype='object')

In [250]: 'd' in index Out[250]: True

You can also pass a name to be stored in the index:

In [251]: index = Index(['e', 'd', 'a', 'b'], name='something')

In [252]: index.name Out[252]: 'something'

The name, if set, will be shown in the console display:

In [253]: index = Index(list(range(5)), name='rows')

In [254]: columns = Index(['A', 'B', 'C'], name='cols')

In [255]: df = DataFrame(np.random.randn(5, 3), index=index, columns=columns)

In [256]: df Out[256]: cols A B C rows
0 0.603791 0.388713 0.544331 1 -0.152978 1.929541 0.202138 2 0.024972 0.117533 -0.184740 3 1.054144 -0.736061 -0.785352 4 -1.362549 -0.063514 0.487562

In [257]: df['A'] Out[257]: rows 0 0.603791 1 -0.152978 2 0.024972 3 1.054144 4 -1.362549 Name: A, dtype: float64

Set operations on Index objects

Warning

In 0.15.0. the set operations + and - were deprecated in order to provide these for numeric type operations on certain index types. + can be replace by .union() or |, and - by .difference().

The two main operations are union (|), intersection (&)These can be directly called as instance methods or used via overloaded operators. Difference is provided via the .difference() method.

In [268]: a = Index(['c', 'b', 'a'])

In [269]: b = Index(['c', 'e', 'd'])

In [270]: a | b Out[270]: Index([u'a', u'b', u'c', u'd', u'e'], dtype='object')

In [271]: a & b Out[271]: Index([u'c'], dtype='object')

In [272]: a.difference(b) Out[272]: Index([u'a', u'b'], dtype='object')

Also available is the sym_diff (^) operation, which returns elements that appear in either idx1 or idx2 but not both. This is equivalent to the Index created by idx1.difference(idx2).union(idx2.difference(idx1)), with duplicates dropped.

In [273]: idx1 = Index([1, 2, 3, 4])

In [274]: idx2 = Index([2, 3, 4, 5])

In [275]: idx1.sym_diff(idx2) Out[275]: Int64Index([1, 5], dtype='int64')

In [276]: idx1 ^ idx2 Out[276]: Int64Index([1, 5], dtype='int64')

Set / Reset Index

Occasionally you will load or create a data set into a DataFrame and want to add an index after you’ve already done so. There are a couple of different ways.

Set an index

DataFrame has a set_index method which takes a column name (for a regularIndex) or a list of column names (for a MultiIndex), to create a new, indexed DataFrame:

In [277]: data Out[277]: a b c d 0 bar one z 1 1 bar two y 2 2 foo one x 3 3 foo two w 4

In [278]: indexed1 = data.set_index('c')

In [279]: indexed1 Out[279]: a b d c
z bar one 1 y bar two 2 x foo one 3 w foo two 4

In [280]: indexed2 = data.set_index(['a', 'b'])

In [281]: indexed2 Out[281]: c d a b
bar one z 1 two y 2 foo one x 3 two w 4

The append keyword option allow you to keep the existing index and append the given columns to a MultiIndex:

In [282]: frame = data.set_index('c', drop=False)

In [283]: frame = frame.set_index(['a', 'b'], append=True)

In [284]: frame Out[284]: c d c a b
z bar one z 1 y bar two y 2 x foo one x 3 w foo two w 4

Other options in set_index allow you not drop the index columns or to add the index in-place (without creating a new object):

In [285]: data.set_index('c', drop=False) Out[285]: a b c d c
z bar one z 1 y bar two y 2 x foo one x 3 w foo two w 4

In [286]: data.set_index(['a', 'b'], inplace=True)

In [287]: data Out[287]: c d a b
bar one z 1 two y 2 foo one x 3 two w 4

Reset the index

As a convenience, there is a new function on DataFrame called reset_indexwhich transfers the index values into the DataFrame’s columns and sets a simple integer index. This is the inverse operation to set_index

In [288]: data Out[288]: c d a b
bar one z 1 two y 2 foo one x 3 two w 4

In [289]: data.reset_index() Out[289]: a b c d 0 bar one z 1 1 bar two y 2 2 foo one x 3 3 foo two w 4

The output is more similar to a SQL table or a record array. The names for the columns derived from the index are the ones stored in the names attribute.

You can use the level keyword to remove only a portion of the index:

In [290]: frame Out[290]: c d c a b
z bar one z 1 y bar two y 2 x foo one x 3 w foo two w 4

In [291]: frame.reset_index(level=1) Out[291]: a c d c b
z one bar z 1 y two bar y 2 x one foo x 3 w two foo w 4

reset_index takes an optional parameter drop which if true simply discards the index, instead of putting index values in the DataFrame’s columns.

Note

The reset_index method used to be called delevel which is now deprecated.

Returning a view versus a copy

When setting values in a pandas object, care must be taken to avoid what is calledchained indexing. Here is an example.

In [292]: dfmi = DataFrame([list('abcd'), .....: list('efgh'), .....: list('ijkl'), .....: list('mnop')], .....: columns=MultiIndex.from_product([['one','two'], .....: ['first','second']])) .....:

In [293]: dfmi Out[293]: one two
first second first second 0 a b c d 1 e f g h 2 i j k l 3 m n o p

Compare these two access methods:

In [294]: dfmi['one']['second'] Out[294]: 0 b 1 f 2 j 3 n Name: second, dtype: object

In [295]: dfmi.loc[:,('one','second')] Out[295]: 0 b 1 f 2 j 3 n Name: (one, second), dtype: object

These both yield the same results, so which should you use? It is instructive to understand the order of operations on these and why method 2 (.loc) is much preferred over method 1 (chained [])

dfmi['one'] selects the first level of the columns and returns a data frame that is singly-indexed. Then another python operation dfmi_with_one['second'] selects the series indexed by 'second' happens. This is indicated by the variable dfmi_with_one because pandas sees these operations as separate events. e.g. separate calls to __getitem__, so it has to treat them as linear operations, they happen one after another.

Contrast this to df.loc[:,('one','second')] which passes a nested tuple of (slice(None),('one','second')) to a single call to__getitem__. This allows pandas to deal with this as a single entity. Furthermore this order of operations can be significantly faster, and allows one to index both axes if so desired.

Why does the assignment when using chained indexing fail¶

So, why does this show the SettingWithCopy warning / and possibly not work when you do chained indexing and assignment:

dfmi['one']['second'] = value

Since the chained indexing is 2 calls, it is possible that either call may return a copy of the data because of the way it is sliced. Thus when setting, you are actually setting a copy, and not the original frame data. It is impossible for pandas to figure this out because their are 2 separate python operations that are not connected.

The SettingWithCopy warning is a ‘heuristic’ to detect this (meaning it tends to catch most cases but is simply a lightweight check). Figuring this out for real is way complicated.

The .loc operation is a single python operation, and thus can select a slice (which still may be a copy), but allows pandas to assign that slice back into the frame after it is modified, thus setting the values as you would think.

The reason for having the SettingWithCopy warning is this. Sometimes when you slice an array you will simply get a view back, which means you can set it no problem. However, even a single dtyped array can generate a copy if it is sliced in a particular way. A multi-dtyped DataFrame (meaning it has say float and object data), will almost always yield a copy. Whether a view is created is dependent on the memory layout of the array.

Evaluation order matters

Furthermore, in chained expressions, the order may determine whether a copy is returned or not. If an expression will set values on a copy of a slice, then a SettingWithCopyexception will be raised (this raise/warn behavior is new starting in 0.13.0)

You can control the action of a chained assignment via the option mode.chained_assignment, which can take the values ['raise','warn',None], where showing a warning is the default.

In [296]: dfb = DataFrame({'a' : ['one', 'one', 'two', .....: 'three', 'two', 'one', 'six'], .....: 'c' : np.arange(7)}) .....:

This will show the SettingWithCopyWarning

but the frame values will be set

In [297]: dfb['c'][dfb.a.str.startswith('o')] = 42

This however is operating on a copy and will not work.

pd.set_option('mode.chained_assignment','warn') dfb[dfb.a.str.startswith('o')]['c'] = 42 Traceback (most recent call last) ... SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame. Try using .loc[row_index,col_indexer] = value instead

A chained assignment can also crop up in setting in a mixed dtype frame.

Note

These setting rules apply to all of .loc/.iloc/.ix

This is the correct access method

In [298]: dfc = DataFrame({'A':['aaa','bbb','ccc'],'B':[1,2,3]})

In [299]: dfc.loc[0,'A'] = 11

In [300]: dfc Out[300]: A B 0 11 1 1 bbb 2 2 ccc 3

This can work at times, but is not guaranteed, and so should be avoided

In [301]: dfc = dfc.copy()

In [302]: dfc['A'][0] = 111

In [303]: dfc Out[303]: A B 0 111 1 1 bbb 2 2 ccc 3

This will not work at all, and so should be avoided

pd.set_option('mode.chained_assignment','raise') dfc.loc[0]['A'] = 1111 Traceback (most recent call last) ... SettingWithCopyException: A value is trying to be set on a copy of a slice from a DataFrame. Try using .loc[row_index,col_indexer] = value instead

Warning

The chained assignment warnings / exceptions are aiming to inform the user of a possibly invalid assignment. There may be false positives; situations where a chained assignment is inadvertantly reported.