Movatterモバイル変換

[0]ホーム
URL:

Navigation

Table Of Contents

Search

Enter search terms or a module, class or function name.

Indexing and Selecting Data

The axis labeling information in pandas objects serves many purposes:

  • Identifies data (i.e. providesmetadata) using known indicators,important for analysis, visualization, and interactive console display
  • Enables automatic and explicit data alignment
  • Allows intuitive getting and setting of subsets of the data set

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 beon Series and DataFrame as they have received more development attention inthis area. Expect more work to be invested in higher-dimensional datastructures (includingPanel) in the future, especially in label-basedadvanced indexing.

Note

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

Warning

Whether a copy or a reference is returned for a setting operation, maydepend on the context. This is sometimes calledchainedassignment andshould be avoided. SeeReturning a View versus Copy

Warning

In 0.15.0Index has internally been refactored to no longer subclassndarraybut instead subclassPandasObject, similarly to the rest of the pandas objects. This should bea transparent change with only very limited API implications (See theInternal Refactoring)

Warning

Indexing on an integer-based Index with floats has been clarified in 0.18.0, for a summary of the changes, seehere.

See theMultiIndex / Advanced Indexing forMultiIndex and more advanced indexing documentation.

See thecookbook 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 tosupport more explicit location based indexing. pandas now supports three typesof multi-axis indexing.

  • .loc is primarily label based, but may also be used with a boolean array..loc will raiseKeyError when the items are not found. Allowed inputs are:

    • A single label, e.g.5 or'a', (note that5 is interpreted as alabel of the index. This use isnot an integer position along theindex)

    • A list or array of labels['a','b','c']

    • A slice object with labels'a':'f', (note that contrary to usual pythonslices,both the start and the stop are included!)

    • A boolean array

    • Acallable function with one argument (the calling Series, DataFrame or Panel) andthat returns valid output for indexing (one of the above)

      New in version 0.18.1.

    See more atSelection by Label

  • .iloc is primarily integer position based (from0 tolength-1 of the axis), but may also be used with a booleanarray..iloc will raiseIndexError if a requestedindexer is out-of-bounds, exceptslice indexers which allowout-of-bounds indexing. (this conforms with python/numpyslicesemantics). Allowed inputs are:

    • An integer e.g.5

    • A list or array of integers[4,3,0]

    • A slice object with ints1:7

    • A boolean array

    • Acallable function with one argument (the calling Series, DataFrame or Panel) andthat returns valid output for indexing (one of the above)

      New in version 0.18.1.

    See more atSelection by Position

  • .ix supports mixed integer and label based access. It is primarily labelbased, but will fall back to integer positional access unless the correspondingaxis is of integer type..ix is the most general and willsupport any of the inputs in.loc and.iloc..ix also supports floating pointlabel schemes..ix is exceptionally useful when dealing with mixed positionaland label based hierarchical indexes.

    However, when an axis is integer based, ONLYlabel based access and not positional access is supported.Thus, in such cases, it’s usually better to be explicit and use.iloc or.loc.

    See more atAdvanced Indexing andAdvancedHierarchical.

  • .loc,.iloc,.ix and also[] indexing can accept acallable as indexer. See more atSelection By Callable.

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

Object TypeIndexers
Seriess.loc[indexer]
DataFramedf.loc[row_indexer,column_indexer]
Panelp.loc[item_indexer,major_indexer,minor_indexer]

Basics

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

Object TypeSelectionReturn Value Type
Seriesseries[label]scalar value
DataFrameframe[colname]Series corresponding to colname
Panelpanel[itemname]DataFrame corresponding to the itemname

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

In [1]:dates=pd.date_range('1/1/2000',periods=8)In [2]:df=pd.DataFrame(np.random.randn(8,4),index=dates,columns=['A','B','C','D'])In [3]:dfOut[3]:                   A         B         C         D2000-01-01  0.469112 -0.282863 -1.509059 -1.1356322000-01-02  1.212112 -0.173215  0.119209 -1.0442362000-01-03 -0.861849 -2.104569 -0.494929  1.0718042000-01-04  0.721555 -0.706771 -1.039575  0.2718602000-01-05 -0.424972  0.567020  0.276232 -1.0874012000-01-06 -0.673690  0.113648 -1.478427  0.5249882000-01-07  0.404705  0.577046 -1.715002 -1.0392682000-01-08 -0.370647 -1.157892 -1.344312  0.844885In [4]:panel=pd.Panel({'one':df,'two':df-df.mean()})In [5]:panelOut[5]:<class 'pandas.core.panel.Panel'>Dimensions: 2 (items) x 8 (major_axis) x 4 (minor_axis)Items axis: one to twoMajor_axis axis: 2000-01-01 00:00:00 to 2000-01-08 00:00:00Minor_axis axis: A to D

Note

None of the indexing functionality is time series specific unlessspecifically 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.67368970808837059In [8]:panel['two']Out[8]:                   A         B         C         D2000-01-01  0.409571  0.113086 -0.610826 -0.9365072000-01-02  1.152571  0.222735  1.017442 -0.8451112000-01-03 -0.921390 -1.708620  0.403304  1.2709292000-01-04  0.662014 -0.310822 -0.141342  0.4709852000-01-05 -0.484513  0.962970  1.174465 -0.8882762000-01-06 -0.733231  0.509598 -0.580194  0.7241132000-01-07  0.345164  0.972995 -0.816769 -0.8401432000-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 beraised. Multiple columns can also be set in this manner:

In [9]:dfOut[9]:                   A         B         C         D2000-01-01  0.469112 -0.282863 -1.509059 -1.1356322000-01-02  1.212112 -0.173215  0.119209 -1.0442362000-01-03 -0.861849 -2.104569 -0.494929  1.0718042000-01-04  0.721555 -0.706771 -1.039575  0.2718602000-01-05 -0.424972  0.567020  0.276232 -1.0874012000-01-06 -0.673690  0.113648 -1.478427  0.5249882000-01-07  0.404705  0.577046 -1.715002 -1.0392682000-01-08 -0.370647 -1.157892 -1.344312  0.844885In [10]:df[['B','A']]=df[['A','B']]In [11]:dfOut[11]:                   A         B         C         D2000-01-01 -0.282863  0.469112 -1.509059 -1.1356322000-01-02 -0.173215  1.212112  0.119209 -1.0442362000-01-03 -2.104569 -0.861849 -0.494929  1.0718042000-01-04 -0.706771  0.721555 -1.039575  0.2718602000-01-05  0.567020 -0.424972  0.276232 -1.0874012000-01-06  0.113648 -0.673690 -1.478427  0.5249882000-01-07  0.577046  0.404705 -1.715002 -1.0392682000-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 thecolumns.

Warning

pandas aligns all AXES when settingSeries andDataFrame from.loc,.iloc and.ix.

This willnot modifydf because the column alignment is before value assignment.

In [12]:df[['A','B']]Out[12]:                   A         B2000-01-01 -0.282863  0.4691122000-01-02 -0.173215  1.2121122000-01-03 -2.104569 -0.8618492000-01-04 -0.706771  0.7215552000-01-05  0.567020 -0.4249722000-01-06  0.113648 -0.6736902000-01-07  0.577046  0.4047052000-01-08 -1.157892 -0.370647In [13]:df.loc[:,['B','A']]=df[['A','B']]In [14]:df[['A','B']]Out[14]:                   A         B2000-01-01 -0.282863  0.4691122000-01-02 -0.173215  1.2121122000-01-03 -2.104569 -0.8618492000-01-04 -0.706771  0.7215552000-01-05  0.567020 -0.4249722000-01-06  0.113648 -0.6736902000-01-07  0.577046  0.4047052000-01-08 -1.157892 -0.370647

The correct way is to use raw values

In [15]:df.loc[:,['B','A']]=df[['A','B']].valuesIn [16]:df[['A','B']]Out[16]:                   A         B2000-01-01  0.469112 -0.2828632000-01-02  1.212112 -0.1732152000-01-03 -0.861849 -2.1045692000-01-04  0.721555 -0.7067712000-01-05 -0.424972  0.5670202000-01-06 -0.673690  0.1136482000-01-07  0.404705  0.5770462000-01-08 -0.370647 -1.157892

Attribute Access

You may access an index on aSeries, column on aDataFrame, and an item on aPanel directlyas an attribute:

In [17]:sa=pd.Series([1,2,3],index=list('abc'))In [18]:dfa=df.copy()
In [19]:sa.bOut[19]:2In [20]:dfa.AOut[20]:2000-01-01    0.4691122000-01-02    1.2121122000-01-03   -0.8618492000-01-04    0.7215552000-01-05   -0.4249722000-01-06   -0.6736902000-01-07    0.4047052000-01-08   -0.370647Freq: D, Name: A, dtype: float64In [21]:panel.oneOut[21]:                   A         B         C         D2000-01-01  0.469112 -0.282863 -1.509059 -1.1356322000-01-02  1.212112 -0.173215  0.119209 -1.0442362000-01-03 -0.861849 -2.104569 -0.494929  1.0718042000-01-04  0.721555 -0.706771 -1.039575  0.2718602000-01-05 -0.424972  0.567020  0.276232 -1.0874012000-01-06 -0.673690  0.113648 -1.478427  0.5249882000-01-07  0.404705  0.577046 -1.715002 -1.0392682000-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 anew column.

In [22]:sa.a=5In [23]:saOut[23]:a    5b    2c    3dtype: int64In [24]:dfa.A=list(range(len(dfa.index)))# ok if A already existsIn [25]:dfaOut[25]:            A         B         C         D2000-01-01  0 -0.282863 -1.509059 -1.1356322000-01-02  1 -0.173215  0.119209 -1.0442362000-01-03  2 -2.104569 -0.494929  1.0718042000-01-04  3 -0.706771 -1.039575  0.2718602000-01-05  4  0.567020  0.276232 -1.0874012000-01-06  5  0.113648 -1.478427  0.5249882000-01-07  6  0.577046 -1.715002 -1.0392682000-01-08  7 -1.157892 -1.344312  0.844885In [26]:dfa['A']=list(range(len(dfa.index)))# use this form to create a new columnIn [27]:dfaOut[27]:            A         B         C         D2000-01-01  0 -0.282863 -1.509059 -1.1356322000-01-02  1 -0.173215  0.119209 -1.0442362000-01-03  2 -2.104569 -0.494929  1.0718042000-01-04  3 -0.706771 -1.039575  0.2718602000-01-05  4  0.567020  0.276232 -1.0874012000-01-06  5  0.113648 -1.478427  0.5249882000-01-07  6  0.577046 -1.715002 -1.0392682000-01-08  7 -1.157892 -1.344312  0.844885

Warning

  • You can use this access only if the index element is a valid python identifier, e.g.s.1 is not allowed.Seehere for an explanation of valid identifiers.
  • The attribute will not be available if it conflicts with an existing method name, e.g.s.min is not allowed.
  • Similarly, the attribute will not be available if it conflicts with any of the following list:index,major_axis,minor_axis,items,labels.
  • In any of these cases, standard indexing will still work, e.g.s['1'],s['min'], ands['index'] willaccess the corresponding element or column.
  • TheSeries/Panel accesses are available starting in 0.13.0.

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

You can also assign adict to a row of aDataFrame:

In [28]:x=pd.DataFrame({'x':[1,2,3],'y':[3,4,5]})In [29]:x.iloc[1]=dict(x=9,y=99)In [30]:xOut[30]:   x   y0  1   31  9  992  3   5

Slicing ranges

The most robust and consistent way of slicing ranges along arbitrary axes isdescribed in theSelection by Position sectiondetailing 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 ofthe values and the corresponding labels:

In [31]:s[:5]Out[31]:2000-01-01    0.4691122000-01-02    1.2121122000-01-03   -0.8618492000-01-04    0.7215552000-01-05   -0.424972Freq: D, Name: A, dtype: float64In [32]:s[::2]Out[32]:2000-01-01    0.4691122000-01-03   -0.8618492000-01-05   -0.4249722000-01-07    0.404705Freq: 2D, Name: A, dtype: float64In [33]:s[::-1]Out[33]:2000-01-08   -0.3706472000-01-07    0.4047052000-01-06   -0.6736902000-01-05   -0.4249722000-01-04    0.7215552000-01-03   -0.8618492000-01-02    1.2121122000-01-01    0.469112Freq: -1D, Name: A, dtype: float64

Note that setting works as well:

In [34]:s2=s.copy()In [35]:s2[:5]=0In [36]:s2Out[36]:2000-01-01    0.0000002000-01-02    0.0000002000-01-03    0.0000002000-01-04    0.0000002000-01-05    0.0000002000-01-06   -0.6736902000-01-07    0.4047052000-01-08   -0.370647Freq: D, Name: A, dtype: float64

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

In [37]:df[:3]Out[37]:                   A         B         C         D2000-01-01  0.469112 -0.282863 -1.509059 -1.1356322000-01-02  1.212112 -0.173215  0.119209 -1.0442362000-01-03 -0.861849 -2.104569 -0.494929  1.071804In [38]:df[::-1]Out[38]:                   A         B         C         D2000-01-08 -0.370647 -1.157892 -1.344312  0.8448852000-01-07  0.404705  0.577046 -1.715002 -1.0392682000-01-06 -0.673690  0.113648 -1.478427  0.5249882000-01-05 -0.424972  0.567020  0.276232 -1.0874012000-01-04  0.721555 -0.706771 -1.039575  0.2718602000-01-03 -0.861849 -2.104569 -0.494929  1.0718042000-01-02  1.212112 -0.173215  0.119209 -1.0442362000-01-01  0.469112 -0.282863 -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 calledchainedassignment and should be avoided.SeeReturning a View versus Copy

Warning

.loc is strict when you present slicers that are not compatible (or convertible) with the index type. For exampleusing integers in aDatetimeIndex. These will raise aTypeError.
In [39]:dfl=pd.DataFrame(np.random.randn(5,4),columns=list('ABCD'),index=pd.date_range('20130101',periods=5))In [40]:dflOut[40]:                   A         B         C         D2013-01-01  1.075770 -0.109050  1.643563 -1.4693882013-01-02  0.357021 -0.674600 -1.776904 -0.9689142013-01-03 -1.294524  0.413738  0.276662 -0.4720352013-01-04 -0.013960 -0.362543 -0.006154 -0.9230612013-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 slicingcan be convertible to the type of the index and lead to natural slicing.

In [41]:dfl.loc['20130102':'20130104']Out[41]:                   A         B         C         D2013-01-02  0.357021 -0.674600 -1.776904 -0.9689142013-01-03 -1.294524  0.413738  0.276662 -0.4720352013-01-04 -0.013960 -0.362543 -0.006154 -0.923061

pandas provides a suite of methods in order to havepurely 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 aKeyError will be raised! When slicing, the start bound isincluded,AND the stop bound isincluded. Integers are valid labels, but they refer to the labeland not the position.

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

  • A single label, e.g.5 or'a', (note that5 is interpreted as alabel of the index. This use isnot an integer position along the index)
  • A list or array of labels['a','b','c']
  • A slice object with labels'a':'f' (note that contrary to usual python slices,both the start and the stop are included!)
  • A boolean array
  • Acallable, seeSelection By Callable
In [42]:s1=pd.Series(np.random.randn(6),index=list('abcdef'))In [43]:s1Out[43]:a    1.431256b    1.340309c   -1.170299d   -0.226169e    0.410835f    0.813850dtype: float64In [44]:s1.loc['c':]Out[44]:c   -1.170299d   -0.226169e    0.410835f    0.813850dtype: float64In [45]:s1.loc['b']Out[45]:1.3403088497993827

Note that setting works as well:

In [46]:s1.loc['c':]=0In [47]:s1Out[47]:a    1.431256b    1.340309c    0.000000d    0.000000e    0.000000f    0.000000dtype: float64

With a DataFrame

In [48]:df1=pd.DataFrame(np.random.randn(6,4),   ....:index=list('abcdef'),   ....:columns=list('ABCD'))   ....:In [49]:df1Out[49]:          A         B         C         Da  0.132003 -0.827317 -0.076467 -1.187678b  1.130127 -1.436737 -1.413681  1.607920c  1.024180  0.569605  0.875906 -2.211372d  0.974466 -2.006747 -0.410001 -0.078638e  0.545952 -1.219217 -1.226825  0.769804f -1.281247 -0.727707 -0.121306 -0.097883In [50]:df1.loc[['a','b','d'],:]Out[50]:          A         B         C         Da  0.132003 -0.827317 -0.076467 -1.187678b  1.130127 -1.436737 -1.413681  1.607920d  0.974466 -2.006747 -0.410001 -0.078638

Accessing via label slices

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

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

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

For getting values with a boolean array

In [53]:df1.loc['a']>0Out[53]:A     TrueB    FalseC    FalseD    FalseName: a, dtype: boolIn [54]:df1.loc[:,df1.loc['a']>0]Out[54]:          Aa  0.132003b  1.130127c  1.024180d  0.974466e  0.545952f -1.281247

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

# this is also equivalent to ``df1.at['a','A']``In [55]:df1.loc['a','A']Out[55]:0.13200317033032932

Selection By Position

Warning

Whether a copy or a reference is returned for a setting operation, may depend on the context.This is sometimes calledchainedassignment and should be avoided.SeeReturning a View versus Copy

pandas provides a suite of methods in order to getpurely integer based indexing. The semantics follow closely python and numpy slicing. These are0-based indexing. When slicing, the start bounds isincluded, while the upper bound isexcluded. Trying to use a non-integer, even avalid label will raise aIndexError.

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

  • An integer e.g.5
  • A list or array of integers[4,3,0]
  • A slice object with ints1:7
  • A boolean array
  • Acallable, seeSelection By Callable
In [56]:s1=pd.Series(np.random.randn(5),index=list(range(0,10,2)))In [57]:s1Out[57]:0    0.6957752    0.3417344    0.9597266   -1.1103368   -0.619976dtype: float64In [58]:s1.iloc[:3]Out[58]:0    0.6957752    0.3417344    0.959726dtype: float64In [59]:s1.iloc[3]Out[59]:-1.1103361028911669

Note that setting works as well:

In [60]:s1.iloc[:3]=0In [61]:s1Out[61]:0    0.0000002    0.0000004    0.0000006   -1.1103368   -0.619976dtype: float64

With a DataFrame

In [62]:df1=pd.DataFrame(np.random.randn(6,4),   ....:index=list(range(0,12,2)),   ....:columns=list(range(0,8,2)))   ....:In [63]:df1Out[63]:           0         2         4         60   0.149748 -0.732339  0.687738  0.1764442   0.403310 -0.154951  0.301624 -2.1798614  -1.369849 -0.954208  1.462696 -1.7431616  -0.826591 -0.345352  1.314232  0.6905798   0.995761  2.396780  0.014871  3.35742710 -0.317441 -1.236269  0.896171 -0.487602

Select via integer slicing

In [64]:df1.iloc[:3]Out[64]:          0         2         4         60  0.149748 -0.732339  0.687738  0.1764442  0.403310 -0.154951  0.301624 -2.1798614 -1.369849 -0.954208  1.462696 -1.743161In [65]:df1.iloc[1:5,2:4]Out[65]:          4         62  0.301624 -2.1798614  1.462696 -1.7431616  1.314232  0.6905798  0.014871  3.357427

Select via integer list

In [66]:df1.iloc[[1,3,5],[1,3]]Out[66]:           2         62  -0.154951 -2.1798616  -0.345352  0.69057910 -1.236269 -0.487602
In [67]:df1.iloc[1:3,:]Out[67]:          0         2         4         62  0.403310 -0.154951  0.301624 -2.1798614 -1.369849 -0.954208  1.462696 -1.743161
In [68]:df1.iloc[:,1:3]Out[68]:           2         40  -0.732339  0.6877382  -0.154951  0.3016244  -0.954208  1.4626966  -0.345352  1.3142328   2.396780  0.01487110 -1.236269  0.896171
# this is also equivalent to ``df1.iat[1,1]``In [69]:df1.iloc[1,1]Out[69]:-0.15495077442490321

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

In [70]:df1.iloc[1]Out[70]:0    0.4033102   -0.1549514    0.3016246   -2.179861Name: 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 [71]:x=list('abcdef')In [72]:xOut[72]:['a','b','c','d','e','f']In [73]:x[4:10]Out[73]:['e','f']In [74]:x[8:10]Out[74]:[]In [75]:s=pd.Series(x)In [76]:sOut[76]:0    a1    b2    c3    d4    e5    fdtype: objectIn [77]:s.iloc[4:10]Out[77]:4    e5    fdtype: objectIn [78]:s.iloc[8:10]Out[78]:Series([],dtype:object)

Note

Prior to v0.14.0,iloc would not accept out of bounds indexers forslices, 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 beingreturned)

In [79]:dfl=pd.DataFrame(np.random.randn(5,2),columns=list('AB'))In [80]:dflOut[80]:          A         B0 -0.082240 -2.1829371  0.380396  0.0848442  0.432390  1.5199703 -0.493662  0.6001784  0.274230  0.132885In [81]:dfl.iloc[:,2:3]Out[81]:Empty DataFrameColumns: []Index: [0, 1, 2, 3, 4]In [82]:dfl.iloc[:,1:3]Out[82]:          B0 -2.1829371  0.0848442  1.5199703  0.6001784  0.132885In [83]:dfl.iloc[4:6]Out[83]:         A         B4  0.27423  0.132885

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

dfl.iloc[[4,5,6]]IndexError:positionalindexersareout-of-boundsdfl.iloc[:,4]IndexError:singlepositionalindexerisout-of-bounds

Selection By Callable

New in version 0.18.1.

.loc,.iloc,.ix and also[] indexing can accept acallable as indexer.Thecallable must be a function with one argument (the calling Series, DataFrame or Panel) and that returns valid output for indexing.

In [84]:df1=pd.DataFrame(np.random.randn(6,4),   ....:index=list('abcdef'),   ....:columns=list('ABCD'))   ....:In [85]:df1Out[85]:          A         B         C         Da -0.023688  2.410179  1.450520  0.206053b -0.251905 -2.213588  1.063327  1.266143c  0.299368 -0.863838  0.408204 -1.048089d -0.025747 -0.988387  0.094055  1.262731e  1.289997  0.082423 -0.055758  0.536580f -0.489682  0.369374 -0.034571 -2.484478In [86]:df1.loc[lambdadf:df.A>0,:]Out[86]:          A         B         C         Dc  0.299368 -0.863838  0.408204 -1.048089e  1.289997  0.082423 -0.055758  0.536580In [87]:df1.loc[:,lambdadf:['A','B']]Out[87]:          A         Ba -0.023688  2.410179b -0.251905 -2.213588c  0.299368 -0.863838d -0.025747 -0.988387e  1.289997  0.082423f -0.489682  0.369374In [88]:df1.iloc[:,lambdadf:[0,1]]Out[88]:          A         Ba -0.023688  2.410179b -0.251905 -2.213588c  0.299368 -0.863838d -0.025747 -0.988387e  1.289997  0.082423f -0.489682  0.369374In [89]:df1[lambdadf:df.columns[0]]Out[89]:a   -0.023688b   -0.251905c    0.299368d   -0.025747e    1.289997f   -0.489682Name: A, dtype: float64

You can use callable indexing inSeries.

In [90]:df1.A.loc[lambdas:s>0]Out[90]:c    0.299368e    1.289997Name: A, dtype: float64

Using these methods / indexers, you can chain data selection operationswithout using temporary variable.

In [91]:bb=pd.read_csv('data/baseball.csv',index_col='id')In [92]:(bb.groupby(['year','team']).sum()   ....:.loc[lambdadf:df.r>100])   ....:Out[92]:           stint    g    ab    r    h  X2b  X3b  hr    rbi    sb   cs   bb  \year team2007 CIN       6  379   745  101  203   35    2  36  125.0  10.0  1.0  105     DET       5  301  1062  162  283   54    4  37  144.0  24.0  7.0   97     HOU       4  311   926  109  218   47    6  14   77.0  10.0  4.0   60     LAN      11  413  1021  153  293   61    3  36  154.0   7.0  5.0  114     NYN      13  622  1854  240  509  101    3  61  243.0  22.0  4.0  174     SFN       5  482  1305  198  337   67    6  40  171.0  26.0  7.0  235     TEX       2  198   729  115  200   40    4  28  115.0  21.0  4.0   73     TOR       4  459  1408  187  378   96    2  58  223.0   4.0  2.0  190              so   ibb   hbp    sh    sf  gidpyear team2007 CIN   127.0  14.0   1.0   1.0  15.0  18.0     DET   176.0   3.0  10.0   4.0   8.0  28.0     HOU   212.0   3.0   9.0  16.0   6.0  17.0     LAN   141.0   8.0   9.0   3.0   8.0  29.0     NYN   310.0  24.0  23.0  18.0  15.0  48.0     SFN   188.0  51.0   8.0  16.0   6.0  41.0     TEX   140.0   4.0   5.0   2.0   8.0  16.0     TOR   265.0  16.0  12.0   4.0  16.0  38.0

Selecting Random Samples

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

In [93]:s=pd.Series([0,1,2,3,4,5])# When no arguments are passed, returns 1 row.In [94]:s.sample()Out[94]:4    4dtype: int64# One may specify either a number of rows:In [95]:s.sample(n=3)Out[95]:0    04    41    1dtype: int64# Or a fraction of the rows:In [96]:s.sample(frac=0.5)Out[96]:5    53    31    1dtype: int64

By default,sample will return each row at most once, but one can also sample with replacementusing thereplace option:

In [97]:s=pd.Series([0,1,2,3,4,5]) # Without replacement (default):In [98]:s.sample(n=6,replace=False)Out[98]:0    01    15    53    32    24    4dtype: int64 # With replacement:In [99]:s.sample(n=6,replace=True)Out[99]:0    04    43    32    24    44    4dtype: int64

By default, each row has an equal probability of being selected, but if you want rowsto have different probabilities, you can pass thesample 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 [100]:s=pd.Series([0,1,2,3,4,5])In [101]:example_weights=[0,0,0.2,0.2,0.2,0.4]In [102]:s.sample(n=3,weights=example_weights)Out[102]:5    54    43    3dtype: int64# Weights will be re-normalized automaticallyIn [103]:example_weights2=[0.5,0,0,0,0,0]In [104]:s.sample(n=1,weights=example_weights2)Out[104]:0    0dtype: 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 columnas a string.

In [105]:df2=pd.DataFrame({'col1':[9,8,7,6],'weight_column':[0.5,0.4,0.1,0]})In [106]:df2.sample(n=3,weights='weight_column')Out[106]:   col1  weight_column1     8            0.40     9            0.52     7            0.1

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

In [107]:df3=pd.DataFrame({'col1':[1,2,3],'col2':[2,3,4]})In [108]:df3.sample(n=1,axis=1)Out[108]:   col10     11     22     3

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

In [109]:df4=pd.DataFrame({'col1':[1,2,3],'col2':[2,3,4]})# With a given seed, the sample will always draw the same rows.In [110]:df4.sample(n=2,random_state=2)Out[110]:   col1  col22     3     41     2     3In [111]:df4.sample(n=2,random_state=2)Out[111]:   col1  col22     3     41     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 theSeries case this is effectively an appending operation

In [112]:se=pd.Series([1,2,3])In [113]:seOut[113]:0    11    22    3dtype: int64In [114]:se[5]=5.In [115]:seOut[115]:0    1.01    2.02    3.05    5.0dtype: float64

ADataFrame can be enlarged on either axis via.loc

In [116]:dfi=pd.DataFrame(np.arange(6).reshape(3,2),   .....:columns=['A','B'])   .....:In [117]:dfiOut[117]:   A  B0  0  11  2  32  4  5In [118]:dfi.loc[:,'C']=dfi.loc[:,'A']In [119]:dfiOut[119]:   A  B  C0  0  1  01  2  3  22  4  5  4

This is like anappend operation on theDataFrame.

In [120]:dfi.loc[3]=5In [121]:dfiOut[121]:   A  B  C0  0  1  01  2  3  22  4  5  43  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 figureout what you’re asking for. If you only want to access a scalar value, thefastest way is to use theat andiat methods, which are implemented onall of the data structures.

Similarly toloc,at provideslabel based scalar lookups, while,iat providesinteger based lookups analogously toiloc

In [122]:s.iat[5]Out[122]:5In [123]:df.at[dates[5],'A']Out[123]:-0.67368970808837059In [124]:df.iat[3,0]Out[124]:0.72155516224436689

You can also set using these same indexers.

In [125]:df.at[dates[5],'E']=7In [126]:df.iat[3,0]=7

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

In [127]:df.at[dates[-1]+1,0]=7In [128]:dfOut[128]:                   A         B         C         D    E    02000-01-01  0.469112 -0.282863 -1.509059 -1.135632  NaN  NaN2000-01-02  1.212112 -0.173215  0.119209 -1.044236  NaN  NaN2000-01-03 -0.861849 -2.104569 -0.494929  1.071804  NaN  NaN2000-01-04  7.000000 -0.706771 -1.039575  0.271860  NaN  NaN2000-01-05 -0.424972  0.567020  0.276232 -1.087401  NaN  NaN2000-01-06 -0.673690  0.113648 -1.478427  0.524988  7.0  NaN2000-01-07  0.404705  0.577046 -1.715002 -1.039268  NaN  NaN2000-01-08 -0.370647 -1.157892 -1.344312  0.844885  NaN  NaN2000-01-09       NaN       NaN       NaN       NaN  NaN  7.0

Boolean indexing

Another common operation is the use of boolean vectors to filter the data.The operators are:| foror,& forand, and~ fornot. Thesemust be grouped by using parentheses.

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

In [129]:s=pd.Series(range(-3,4))In [130]:sOut[130]:0   -31   -22   -13    04    15    26    3dtype: int64In [131]:s[s>0]Out[131]:4    15    26    3dtype: int64In [132]:s[(s<-1)|(s>0.5)]Out[132]:0   -31   -24    15    26    3dtype: int64In [133]:s[~(s<0)]Out[133]:3    04    15    26    3dtype: int64

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

In [134]:df[df['A']>0]Out[134]:                   A         B         C         D   E   02000-01-01  0.469112 -0.282863 -1.509059 -1.135632 NaN NaN2000-01-02  1.212112 -0.173215  0.119209 -1.044236 NaN NaN2000-01-04  7.000000 -0.706771 -1.039575  0.271860 NaN NaN2000-01-07  0.404705  0.577046 -1.715002 -1.039268 NaN NaN

List comprehensions andmap method of Series can also be used to producemore complex criteria:

In [135]:df2=pd.DataFrame({'a':['one','one','two','three','two','one','six'],   .....:'b':['x','y','y','x','y','x','x'],   .....:'c':np.random.randn(7)})   .....:# only want 'two' or 'three'In [136]:criterion=df2['a'].map(lambdax:x.startswith('t'))In [137]:df2[criterion]Out[137]:       a  b         c2    two  y  0.0412903  three  x  0.3617194    two  y -0.238075# equivalent but slowerIn [138]:df2[[x.startswith('t')forxindf2['a']]]Out[138]:       a  b         c2    two  y  0.0412903  three  x  0.3617194    two  y -0.238075# Multiple criteriaIn [139]:df2[criterion&(df2['b']=='x')]Out[139]:       a  b         c3  three  x  0.361719

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

In [140]:df2.loc[criterion&(df2['b']=='x'),'b':'c']Out[140]:   b         c3  x  0.361719

Indexing with isin

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

In [141]:s=pd.Series(np.arange(5),index=np.arange(5)[::-1],dtype='int64')In [142]:sOut[142]:4    03    12    21    30    4dtype: int64In [143]:s.isin([2,4,6])Out[143]:4    False3    False2     True1    False0     Truedtype: boolIn [144]:s[s.isin([2,4,6])]Out[144]:2    20    4dtype: int64

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

In [145]:s[s.index.isin([2,4,6])]Out[145]:4    02    2dtype: int64# compare it to the followingIn [146]:s[[2,4,6]]Out[146]:2    2.04    0.06    NaNdtype: float64

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

In [147]:s_mi=pd.Series(np.arange(6),   .....:index=pd.MultiIndex.from_product([[0,1],['a','b','c']]))   .....:In [148]:s_miOut[148]:0  a    0   b    1   c    21  a    3   b    4   c    5dtype: int64In [149]:s_mi.iloc[s_mi.index.isin([(1,'a'),(2,'b'),(0,'c')])]Out[149]:0  c    21  a    3dtype: int64In [150]:s_mi.iloc[s_mi.index.isin(['a','c','e'],level=1)]Out[150]:0  a    0   c    21  a    3   c    5dtype: int64

DataFrame also has anisin method. When callingisin, pass a set ofvalues as either an array or dict. If values is an array,isin returnsa DataFrame of booleans that is the same shape as the original DataFrame, with Truewherever the element is in the sequence of values.

In [151]:df=pd.DataFrame({'vals':[1,2,3,4],'ids':['a','b','f','n'],   .....:'ids2':['a','n','c','n']})   .....:In [152]:values=['a','b',1,3]In [153]:df.isin(values)Out[153]:     ids   ids2   vals0   True   True   True1   True  False  False2  False  False   True3  False  False  False

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

In [154]:values={'ids':['a','b'],'vals':[1,3]}In [155]:df.isin(values)Out[155]:     ids   ids2   vals0   True  False   True1   True  False  False2  False  False   True3  False  False  False

Combine DataFrame’sisin with theany() andall() methods toquickly select subsets of your data that meet a given criteria.To select a row where each column meets its own criterion:

In [156]:values={'ids':['a','b'],'ids2':['a','c'],'vals':[1,3]}In [157]:row_mask=df.isin(values).all(1)In [158]:df[row_mask]Out[158]:  ids ids2  vals0   a    a     1

Thewhere() Method and Masking

Selecting values from a Series with a boolean vector generally returns asubset of the data. To guarantee that selection output has the same shape asthe original data, you can use thewhere method inSeries andDataFrame.

To return only the selected rows

In [159]:s[s>0]Out[159]:3    12    21    30    4dtype: int64

To return a Series of the same shape as the original

In [160]:s.where(s>0)Out[160]:4    NaN3    1.02    2.01    3.00    4.0dtype: float64

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

In [161]:df[df<0]Out[161]:                   A         B         C         D2000-01-01 -2.104139 -1.309525       NaN       NaN2000-01-02 -0.352480       NaN -1.192319       NaN2000-01-03 -0.864883       NaN -0.227870       NaN2000-01-04       NaN -1.222082       NaN -1.2332032000-01-05       NaN -0.605656 -1.169184       NaN2000-01-06       NaN -0.948458       NaN -0.6847182000-01-07 -2.670153 -0.114722       NaN -0.0480482000-01-08       NaN       NaN -0.048788 -0.808838

In addition,where takes an optionalother argument for replacement ofvalues where the condition is False, in the returned copy.

In [162]:df.where(df<0,-df)Out[162]:                   A         B         C         D2000-01-01 -2.104139 -1.309525 -0.485855 -0.2451662000-01-02 -0.352480 -0.390389 -1.192319 -1.6558242000-01-03 -0.864883 -0.299674 -0.227870 -0.2810592000-01-04 -0.846958 -1.222082 -0.600705 -1.2332032000-01-05 -0.669692 -0.605656 -1.169184 -0.3424162000-01-06 -0.868584 -0.948458 -2.297780 -0.6847182000-01-07 -2.670153 -0.114722 -0.168904 -0.0480482000-01-08 -0.801196 -1.392071 -0.048788 -0.808838

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

In [163]:s2=s.copy()In [164]:s2[s2<0]=0In [165]:s2Out[165]:4    03    12    21    30    4dtype: int64In [166]:df2=df.copy()In [167]:df2[df2<0]=0In [168]:df2Out[168]:                   A         B         C         D2000-01-01  0.000000  0.000000  0.485855  0.2451662000-01-02  0.000000  0.390389  0.000000  1.6558242000-01-03  0.000000  0.299674  0.000000  0.2810592000-01-04  0.846958  0.000000  0.600705  0.0000002000-01-05  0.669692  0.000000  0.000000  0.3424162000-01-06  0.868584  0.000000  2.297780  0.0000002000-01-07  0.000000  0.000000  0.168904  0.0000002000-01-08  0.801196  1.392071  0.000000  0.000000

By default,where returns a modified copy of the data. There is anoptional parameterinplace so that the original data can be modifiedwithout creating a copy:

In [169]:df_orig=df.copy()In [170]:df_orig.where(df>0,-df,inplace=True);In [171]:df_origOut[171]:                   A         B         C         D2000-01-01  2.104139  1.309525  0.485855  0.2451662000-01-02  0.352480  0.390389  1.192319  1.6558242000-01-03  0.864883  0.299674  0.227870  0.2810592000-01-04  0.846958  1.222082  0.600705  1.2332032000-01-05  0.669692  0.605656  1.169184  0.3424162000-01-06  0.868584  0.948458  2.297780  0.6847182000-01-07  2.670153  0.114722  0.168904  0.0480482000-01-08  0.801196  1.392071  0.048788  0.808838

Note

The signature forDataFrame.where() differs fromnumpy.where().Roughlydf1.where(m,df2) is equivalent tonp.where(m,df1,df2).

In [172]:df.where(df<0,-df)==np.where(df<0,df,-df)Out[172]:               A     B     C     D2000-01-01  True  True  True  True2000-01-02  True  True  True  True2000-01-03  True  True  True  True2000-01-04  True  True  True  True2000-01-05  True  True  True  True2000-01-06  True  True  True  True2000-01-07  True  True  True  True2000-01-08  True  True  True  True

alignment

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

In [173]:df2=df.copy()In [174]:df2[df2[1:4]>0]=3In [175]:df2Out[175]:                   A         B         C         D2000-01-01 -2.104139 -1.309525  0.485855  0.2451662000-01-02 -0.352480  3.000000 -1.192319  3.0000002000-01-03 -0.864883  3.000000 -0.227870  3.0000002000-01-04  3.000000 -1.222082  3.000000 -1.2332032000-01-05  0.669692 -0.605656 -1.169184  0.3424162000-01-06  0.868584 -0.948458  2.297780 -0.6847182000-01-07 -2.670153 -0.114722  0.168904 -0.0480482000-01-08  0.801196  1.392071 -0.048788 -0.808838

New in version 0.13.

Where can also acceptaxis andlevel parameters to align the input whenperforming thewhere.

In [176]:df2=df.copy()In [177]:df2.where(df2>0,df2['A'],axis='index')Out[177]:                   A         B         C         D2000-01-01 -2.104139 -2.104139  0.485855  0.2451662000-01-02 -0.352480  0.390389 -0.352480  1.6558242000-01-03 -0.864883  0.299674 -0.864883  0.2810592000-01-04  0.846958  0.846958  0.600705  0.8469582000-01-05  0.669692  0.669692  0.669692  0.3424162000-01-06  0.868584  0.868584  2.297780  0.8685842000-01-07 -2.670153 -2.670153  0.168904 -2.6701532000-01-08  0.801196  1.392071  0.801196  0.801196

This is equivalent (but faster than) the following.

In [178]:df2=df.copy()In [179]:df.apply(lambdax,y:x.where(x>0,y),y=df['A'])Out[179]:                   A         B         C         D2000-01-01 -2.104139 -2.104139  0.485855  0.2451662000-01-02 -0.352480  0.390389 -0.352480  1.6558242000-01-03 -0.864883  0.299674 -0.864883  0.2810592000-01-04  0.846958  0.846958  0.600705  0.8469582000-01-05  0.669692  0.669692  0.669692  0.3424162000-01-06  0.868584  0.868584  2.297780  0.8685842000-01-07 -2.670153 -2.670153  0.168904 -2.6701532000-01-08  0.801196  1.392071  0.801196  0.801196

New in version 0.18.1.

Where can accept a callable as condition andother arguments. The function mustbe with one argument (the calling Series or DataFrame) and that returns valid outputas condition andother argument.

In [180]:df3=pd.DataFrame({'A':[1,2,3],   .....:'B':[4,5,6],   .....:'C':[7,8,9]})   .....:In [181]:df3.where(lambdax:x>4,lambdax:x+10)Out[181]:    A   B  C0  11  14  71  12   5  82  13   6  9

mask

mask is the inverse boolean operation ofwhere.

In [182]:s.mask(s>=0)Out[182]:4   NaN3   NaN2   NaN1   NaN0   NaNdtype: float64In [183]:df.mask(df>=0)Out[183]:                   A         B         C         D2000-01-01 -2.104139 -1.309525       NaN       NaN2000-01-02 -0.352480       NaN -1.192319       NaN2000-01-03 -0.864883       NaN -0.227870       NaN2000-01-04       NaN -1.222082       NaN -1.2332032000-01-05       NaN -0.605656 -1.169184       NaN2000-01-06       NaN -0.948458       NaN -0.6847182000-01-07 -2.670153 -0.114722       NaN -0.0480482000-01-08       NaN       NaN -0.048788 -0.808838

Thequery() Method (Experimental)

New in version 0.13.

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

You can get the value of the frame where columnb has valuesbetween the values of columnsa andc. For example:

In [184]:n=10In [185]:df=pd.DataFrame(np.random.rand(n,3),columns=list('abc'))In [186]:dfOut[186]:          a         b         c0  0.438921  0.118680  0.8636701  0.138138  0.577363  0.6866022  0.595307  0.564592  0.5206303  0.913052  0.926075  0.6161844  0.078718  0.854477  0.8987255  0.076404  0.523211  0.5915386  0.792342  0.216974  0.5640567  0.397890  0.454131  0.9157168  0.074315  0.437913  0.0197949  0.559209  0.502065  0.026437# pure pythonIn [187]:df[(df.a<df.b)&(df.b<df.c)]Out[187]:          a         b         c1  0.138138  0.577363  0.6866024  0.078718  0.854477  0.8987255  0.076404  0.523211  0.5915387  0.397890  0.454131  0.915716# queryIn [188]:df.query('(a < b) & (b < c)')Out[188]:          a         b         c1  0.138138  0.577363  0.6866024  0.078718  0.854477  0.8987255  0.076404  0.523211  0.5915387  0.397890  0.454131  0.915716

Do the same thing but fall back on a named index if there is no columnwith the namea.

In [189]:df=pd.DataFrame(np.random.randint(n/2,size=(n,2)),columns=list('bc'))In [190]:df.index.name='a'In [191]:dfOut[191]:   b  ca0  0  41  0  12  3  43  4  34  1  45  0  36  0  17  3  48  2  39  1  1In [192]:df.query('a < b and b < c')Out[192]:   b  ca2  3  4

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

In [193]:df=pd.DataFrame(np.random.randint(n,size=(n,2)),columns=list('bc'))In [194]:dfOut[194]:   b  c0  3  11  3  02  5  63  5  24  7  45  0  16  2  57  0  18  6  09  7  9In [195]:df.query('index < b < c')Out[195]:   b  c2  5  6

Note

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

In [196]:df=pd.DataFrame({'a':np.random.randint(5,size=5)})In [197]:df.index.name='a'In [198]:df.query('a > 2')# uses the column 'a', not the indexOut[198]:   aa1  33  3

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

In [199]:df.query('index > 2')Out[199]:   aa3  34  2

If for some reason you have a column namedindex, then you can refer tothe index asilevel_0 as well, but at this point you should considerrenaming your columns to something less ambiguous.

MultiIndexquery() Syntax

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

In [200]:n=10In [201]:colors=np.random.choice(['red','green'],size=n)In [202]:foods=np.random.choice(['eggs','ham'],size=n)In [203]:colorsOut[203]:array(['red', 'red', 'red', 'green', 'green', 'green', 'green', 'green',       'green', 'green'],      dtype='|S5')In [204]:foodsOut[204]:array(['ham', 'ham', 'eggs', 'eggs', 'eggs', 'ham', 'ham', 'eggs', 'eggs',       'eggs'],      dtype='|S4')In [205]:index=pd.MultiIndex.from_arrays([colors,foods],names=['color','food'])In [206]:df=pd.DataFrame(np.random.randn(n,2),index=index)In [207]:dfOut[207]:                   0         1color foodred   ham   0.194889 -0.381994      ham   0.318587  2.089075      eggs -0.728293 -0.090255green eggs -0.748199  1.318931      eggs -2.029766  0.792652      ham   0.461007 -0.542749      ham  -0.305384 -0.479195      eggs  0.095031 -0.270099      eggs -0.707140 -0.773882      eggs  0.229453  0.304418In [208]:df.query('color == "red"')Out[208]:                   0         1color foodred   ham   0.194889 -0.381994      ham   0.318587  2.089075      eggs -0.728293 -0.090255

If the levels of theMultiIndex are unnamed, you can refer to them usingspecial names:

In [209]:df.index.names=[None,None]In [210]:dfOut[210]:                   0         1red   ham   0.194889 -0.381994      ham   0.318587  2.089075      eggs -0.728293 -0.090255green eggs -0.748199  1.318931      eggs -2.029766  0.792652      ham   0.461007 -0.542749      ham  -0.305384 -0.479195      eggs  0.095031 -0.270099      eggs -0.707140 -0.773882      eggs  0.229453  0.304418In [211]:df.query('ilevel_0 == "red"')Out[211]:                 0         1red ham   0.194889 -0.381994    ham   0.318587  2.089075    eggs -0.728293 -0.090255

The convention isilevel_0, which means “index level 0” for the 0th levelof theindex.

query() Use Cases

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

In [212]:df=pd.DataFrame(np.random.rand(n,3),columns=list('abc'))In [213]:dfOut[213]:          a         b         c0  0.224283  0.736107  0.1391681  0.302827  0.657803  0.7138972  0.611185  0.136624  0.9849603  0.195246  0.123436  0.6277124  0.618673  0.371660  0.0479025  0.480088  0.062993  0.1857606  0.568018  0.483467  0.4452897  0.309040  0.274580  0.5871018  0.258993  0.477769  0.3702559  0.550459  0.840870  0.304611In [214]:df2=pd.DataFrame(np.random.rand(n+2,3),columns=df.columns)In [215]:df2Out[215]:           a         b         c0   0.357579  0.229800  0.5960011   0.309059  0.957923  0.9656632   0.123102  0.336914  0.3186163   0.526506  0.323321  0.8608134   0.518736  0.486514  0.3847245   0.190804  0.505723  0.6145336   0.891939  0.623977  0.6766397   0.480559  0.378528  0.4608588   0.420223  0.136404  0.1412959   0.732206  0.419540  0.60467510  0.604466  0.848974  0.89616511  0.589168  0.920046  0.732716In [216]:expr='0.0 <= a <= c <= 0.5'In [217]:map(lambdaframe:frame.query(expr),[df,df2])Out[217]:[          a         b         c 8  0.258993  0.477769  0.370255,           a         b         c 2  0.123102  0.336914  0.318616]

query() Python versus pandas Syntax Comparison

Full numpy-like syntax

In [218]:df=pd.DataFrame(np.random.randint(n,size=(n,3)),columns=list('abc'))In [219]:dfOut[219]:   a  b  c0  7  8  91  1  0  72  2  7  23  6  2  24  2  6  35  3  8  26  1  7  27  5  1  58  9  8  09  1  5  0In [220]:df.query('(a < b) & (b < c)')Out[220]:   a  b  c0  7  8  9In [221]:df[(df.a<df.b)&(df.b<df.c)]Out[221]:   a  b  c0  7  8  9

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

In [222]:df.query('a < b & b < c')Out[222]:   a  b  c0  7  8  9

Use English instead of symbols

In [223]:df.query('a < b and b < c')Out[223]:   a  b  c0  7  8  9

Pretty close to how you might write it on paper

In [224]:df.query('a < b < c')Out[224]:   a  b  c0  7  8  9

Thein andnotin operators

query() also supports special use of Python’sin andnotin comparison operators, providing a succinct syntax for calling theisin method of aSeries orDataFrame.

# get all rows where columns "a" and "b" have overlapping valuesIn [225]:df=pd.DataFrame({'a':list('aabbccddeeff'),'b':list('aaaabbbbcccc'),   .....:'c':np.random.randint(5,size=12),   .....:'d':np.random.randint(9,size=12)})   .....:In [226]:dfOut[226]:    a  b  c  d0   a  a  2  61   a  a  4  72   b  a  1  63   b  a  2  14   c  b  3  65   c  b  0  26   d  b  3  37   d  b  2  18   e  c  4  39   e  c  2  010  f  c  0  611  f  c  1  2In [227]:df.query('a in b')Out[227]:   a  b  c  d0  a  a  2  61  a  a  4  72  b  a  1  63  b  a  2  14  c  b  3  65  c  b  0  2# How you'd do it in pure PythonIn [228]:df[df.a.isin(df.b)]Out[228]:   a  b  c  d0  a  a  2  61  a  a  4  72  b  a  1  63  b  a  2  14  c  b  3  65  c  b  0  2In [229]:df.query('a not in b')Out[229]:    a  b  c  d6   d  b  3  37   d  b  2  18   e  c  4  39   e  c  2  010  f  c  0  611  f  c  1  2# pure PythonIn [230]:df[~df.a.isin(df.b)]Out[230]:    a  b  c  d6   d  b  3  37   d  b  2  18   e  c  4  39   e  c  2  010  f  c  0  611  f  c  1  2

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'sIn [231]:df.query('a in b and c < d')Out[231]:   a  b  c  d0  a  a  2  61  a  a  4  72  b  a  1  64  c  b  3  65  c  b  0  2# pure PythonIn [232]:df[df.b.isin(df.a)&(df.c<df.d)]Out[232]:    a  b  c  d0   a  a  2  61   a  a  4  72   b  a  1  64   c  b  3  65   c  b  0  210  f  c  0  611  f  c  1  2

Note

Note thatin andnotin are evaluated in Python, sincenumexprhas no equivalent of this operation. However,only thein/notinexpression itself is evaluated in vanilla Python. For example, in theexpression

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

(b+c+d) is evaluated bynumexpr andthen theinoperation is evaluated in plain Python. In general, any operations that canbe evaluated usingnumexpr will be.

Special use of the== operator withlist objects

Comparing alist of values to a column using==/!= works similarlytoin/notin

In [233]:df.query('b == ["a", "b", "c"]')Out[233]:    a  b  c  d0   a  a  2  61   a  a  4  72   b  a  1  63   b  a  2  14   c  b  3  65   c  b  0  26   d  b  3  37   d  b  2  18   e  c  4  39   e  c  2  010  f  c  0  611  f  c  1  2# pure PythonIn [234]:df[df.b.isin(["a","b","c"])]Out[234]:    a  b  c  d0   a  a  2  61   a  a  4  72   b  a  1  63   b  a  2  14   c  b  3  65   c  b  0  26   d  b  3  37   d  b  2  18   e  c  4  39   e  c  2  010  f  c  0  611  f  c  1  2In [235]:df.query('c == [1, 2]')Out[235]:    a  b  c  d0   a  a  2  62   b  a  1  63   b  a  2  17   d  b  2  19   e  c  2  011  f  c  1  2In [236]:df.query('c != [1, 2]')Out[236]:    a  b  c  d1   a  a  4  74   c  b  3  65   c  b  0  26   d  b  3  38   e  c  4  310  f  c  0  6# using in/not inIn [237]:df.query('[1, 2] in c')Out[237]:    a  b  c  d0   a  a  2  62   b  a  1  63   b  a  2  17   d  b  2  19   e  c  2  011  f  c  1  2In [238]:df.query('[1, 2] not in c')Out[238]:    a  b  c  d1   a  a  4  74   c  b  3  65   c  b  0  26   d  b  3  38   e  c  4  310  f  c  0  6# pure PythonIn [239]:df[df.c.isin([1,2])]Out[239]:    a  b  c  d0   a  a  2  62   b  a  1  63   b  a  2  17   d  b  2  19   e  c  2  011  f  c  1  2

Boolean Operators

You can negate boolean expressions with the wordnot or the~ operator.

In [240]:df=pd.DataFrame(np.random.rand(n,3),columns=list('abc'))In [241]:df['bools']=np.random.rand(len(df))>0.5In [242]:df.query('~bools')Out[242]:          a         b         c  bools2  0.697753  0.212799  0.329209  False7  0.275396  0.691034  0.826619  False8  0.190649  0.558748  0.262467  FalseIn [243]:df.query('not bools')Out[243]:          a         b         c  bools2  0.697753  0.212799  0.329209  False7  0.275396  0.691034  0.826619  False8  0.190649  0.558748  0.262467  FalseIn [244]:df.query('not bools')==df[~df.bools]Out[244]:      a     b     c bools2  True  True  True  True7  True  True  True  True8  True  True  True  True

Of course, expressions can be arbitrarily complex too

# short query syntaxIn [245]:shorter=df.query('a < b < c and (not bools) or bools > 2')# equivalent in pure PythonIn [246]:longer=df[(df.a<df.b)&(df.b<df.c)&(~df.bools)|(df.bools>2)]In [247]:shorterOut[247]:          a         b         c  bools7  0.275396  0.691034  0.826619  FalseIn [248]:longerOut[248]:          a         b         c  bools7  0.275396  0.691034  0.826619  FalseIn [249]:shorter==longerOut[249]:      a     b     c bools7  True  True  True  True

Performance ofquery()

DataFrame.query() usingnumexpr is slightly faster than Python forlarge frames

_images/query-perf.png

Note

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

_images/query-perf-small.png

This plot was created using aDataFrame with 3 columns each containingfloating point values generated usingnumpy.random.randn().

Duplicate Data

If you want to identify and remove duplicate rows in a DataFrame, there aretwo methods that will help:duplicated anddrop_duplicates. Eachtakes as an argument the columns to use to identify duplicated rows.

  • duplicated returns a boolean vector whose length is the number of rows, and which indicates whether a row is duplicated.
  • drop_duplicates removes duplicate rows.

By default, the first observed row of a duplicate set is considered unique, buteach method has akeep parameter to specify targets to be kept.

  • keep='first' (default): mark / drop duplicates except for the first occurrence.
  • keep='last': mark / drop duplicates except for the last occurrence.
  • keep=False: mark / drop all duplicates.
In [250]:df2=pd.DataFrame({'a':['one','one','two','two','two','three','four'],   .....:'b':['x','y','x','y','x','x','x'],   .....:'c':np.random.randn(7)})   .....:In [251]:df2Out[251]:       a  b         c0    one  x -1.0671371    one  y  0.3095002    two  x -0.2110563    two  y -1.8420234    two  x -0.3908205  three  x -1.9644756   four  x  1.298329In [252]:df2.duplicated('a')Out[252]:0    False1     True2    False3     True4     True5    False6    Falsedtype: boolIn [253]:df2.duplicated('a',keep='last')Out[253]:0     True1    False2     True3     True4    False5    False6    Falsedtype: boolIn [254]:df2.duplicated('a',keep=False)Out[254]:0     True1     True2     True3     True4     True5    False6    Falsedtype: boolIn [255]:df2.drop_duplicates('a')Out[255]:       a  b         c0    one  x -1.0671372    two  x -0.2110565  three  x -1.9644756   four  x  1.298329In [256]:df2.drop_duplicates('a',keep='last')Out[256]:       a  b         c1    one  y  0.3095004    two  x -0.3908205  three  x -1.9644756   four  x  1.298329In [257]:df2.drop_duplicates('a',keep=False)Out[257]:       a  b         c5  three  x -1.9644756   four  x  1.298329

Also, you can pass a list of columns to identify duplications.

In [258]:df2.duplicated(['a','b'])Out[258]:0    False1    False2    False3    False4     True5    False6    Falsedtype: boolIn [259]:df2.drop_duplicates(['a','b'])Out[259]:       a  b         c0    one  x -1.0671371    one  y  0.3095002    two  x -0.2110563    two  y -1.8420235  three  x -1.9644756   four  x  1.298329

To drop duplicates by index value, useIndex.duplicated then perform slicing.Same options are available inkeep parameter.

In [260]:df3=pd.DataFrame({'a':np.arange(6),   .....:'b':np.random.randn(6)},   .....:index=['a','a','b','c','b','a'])   .....:In [261]:df3Out[261]:   a         ba  0  1.440455a  1  2.456086b  2  1.038402c  3 -0.894409b  4  0.683536a  5  3.082764In [262]:df3.index.duplicated()Out[262]:array([False,True,False,False,True,True],dtype=bool)In [263]:df3[~df3.index.duplicated()]Out[263]:   a         ba  0  1.440455b  2  1.038402c  3 -0.894409In [264]:df3[~df3.index.duplicated(keep='last')]Out[264]:   a         bc  3 -0.894409b  4  0.683536a  5  3.082764In [265]:df3[~df3.index.duplicated(keep=False)]Out[265]:   a         bc  3 -0.894409

Dictionary-likeget() method

Each of Series, DataFrame, and Panel have aget method which can return adefault value.

In [266]:s=pd.Series([1,2,3],index=['a','b','c'])In [267]:s.get('a')# equivalent to s['a']Out[267]:1In [268]:s.get('x',default=-1)Out[268]:-1

Theselect() Method

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

In [269]:df.select(lambdax:x=='A',axis=1)Out[269]:                   A2000-01-01  0.3557942000-01-02  1.6357632000-01-03  0.8544092000-01-04 -0.2166592000-01-05  2.4146882000-01-06 -1.2062152000-01-07  0.7794612000-01-08 -0.878999

Thelookup() Method

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

In [270]:dflookup=pd.DataFrame(np.random.rand(20,4),columns=['A','B','C','D'])In [271]:dflookup.lookup(list(range(0,10,2)),['B','C','A','B','D'])Out[271]:array([0.3506,0.4779,0.4825,0.9197,0.5019])

Index objects

The pandasIndex class and its subclasses can be viewed asimplementing anordered multiset. Duplicates are allowed. However, if you tryto convert anIndex object with duplicate entries into aset, an exception will be raised.

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

In [272]:index=pd.Index(['e','d','a','b'])In [273]:indexOut[273]:Index([u'e',u'd',u'a',u'b'],dtype='object')In [274]:'d'inindexOut[274]:True

You can also pass aname to be stored in the index:

In [275]:index=pd.Index(['e','d','a','b'],name='something')In [276]:index.nameOut[276]:'something'

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

In [277]:index=pd.Index(list(range(5)),name='rows')In [278]:columns=pd.Index(['A','B','C'],name='cols')In [279]:df=pd.DataFrame(np.random.randn(5,3),index=index,columns=columns)In [280]:dfOut[280]:cols         A         B         Crows0     1.295989  0.185778  0.4362591     0.678101  0.311369 -0.5283782    -0.674808 -1.103529 -0.6561573     1.889957  2.076651 -1.1021924    -1.211795 -0.791746  0.634724In [281]:df['A']Out[281]:rows0    1.2959891    0.6781012   -0.6748083    1.8899574   -1.211795Name: A, dtype: float64

Setting metadata

New in version 0.13.0.

Indexes are “mostly immutable”, but it is possible to set and change theirmetadata, like the indexname (or, forMultiIndex,levels andlabels).

You can use therename,set_names,set_levels, andset_labelsto set these attributes directly. They default to returning a copy; however,you can specifyinplace=True to have the data change in place.

SeeAdvanced Indexing for usage of MultiIndexes.

In [282]:ind=pd.Index([1,2,3])In [283]:ind.rename("apple")Out[283]:Int64Index([1,2,3],dtype='int64',name=u'apple')In [284]:indOut[284]:Int64Index([1,2,3],dtype='int64')In [285]:ind.set_names(["apple"],inplace=True)In [286]:ind.name="bob"In [287]:indOut[287]:Int64Index([1,2,3],dtype='int64',name=u'bob')

New in version 0.15.0.

set_names,set_levels, andset_labels also take an optionallevel` argument

In [288]:index=pd.MultiIndex.from_product([range(3),['one','two']],names=['first','second'])In [289]:indexOut[289]:MultiIndex(levels=[[0, 1, 2], [u'one', u'two']],           labels=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],           names=[u'first', u'second'])In [290]:index.levels[1]Out[290]:Index([u'one',u'two'],dtype='object',name=u'second')In [291]:index.set_levels(["a","b"],level=1)Out[291]:MultiIndex(levels=[[0, 1, 2], [u'a', u'b']],           labels=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],           names=[u'first', u'second'])

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 certainindex types.+ can be replace by.union() or|, and- by.difference().

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

In [292]:a=pd.Index(['c','b','a'])In [293]:b=pd.Index(['c','e','d'])In [294]:a|bOut[294]:Index([u'a',u'b',u'c',u'd',u'e'],dtype='object')In [295]:a&bOut[295]:Index([u'c'],dtype='object')In [296]:a.difference(b)Out[296]:Index([u'a',u'b'],dtype='object')

Also available is thesymmetric_difference(^) operation, which returns elementsthat appear in eitheridx1 oridx2 but not both. This isequivalent to the Index created byidx1.difference(idx2).union(idx2.difference(idx1)),with duplicates dropped.

In [297]:idx1=pd.Index([1,2,3,4])In [298]:idx2=pd.Index([2,3,4,5])In [299]:idx1.symmetric_difference(idx2)Out[299]:Int64Index([1,5],dtype='int64')In [300]:idx1^idx2Out[300]:Int64Index([1,5],dtype='int64')

Missing values

New in version 0.17.1.

Important

Even thoughIndex can hold missing values (NaN), it should be avoidedif you do not want any unexpected results. For example, some operationsexclude missing values implicitly.

Index.fillna fills missing values with specified scalar value.

In [301]:idx1=pd.Index([1,np.nan,3,4])In [302]:idx1Out[302]:Float64Index([1.0,nan,3.0,4.0],dtype='float64')In [303]:idx1.fillna(2)Out[303]:Float64Index([1.0,2.0,3.0,4.0],dtype='float64')In [304]:idx2=pd.DatetimeIndex([pd.Timestamp('2011-01-01'),pd.NaT,pd.Timestamp('2011-01-03')])In [305]:idx2Out[305]:DatetimeIndex(['2011-01-01','NaT','2011-01-03'],dtype='datetime64[ns]',freq=None)In [306]:idx2.fillna(pd.Timestamp('2011-01-02'))Out[306]:DatetimeIndex(['2011-01-01','2011-01-02','2011-01-03'],dtype='datetime64[ns]',freq=None)

Set / Reset Index

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

Set an index

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

In [307]:dataOut[307]:     a    b  c    d0  bar  one  z  1.01  bar  two  y  2.02  foo  one  x  3.03  foo  two  w  4.0In [308]:indexed1=data.set_index('c')In [309]:indexed1Out[309]:     a    b    dcz  bar  one  1.0y  bar  two  2.0x  foo  one  3.0w  foo  two  4.0In [310]:indexed2=data.set_index(['a','b'])In [311]:indexed2Out[311]:         c    da   bbar one  z  1.0    two  y  2.0foo one  x  3.0    two  w  4.0

Theappend keyword option allow you to keep the existing index and appendthe given columns to a MultiIndex:

In [312]:frame=data.set_index('c',drop=False)In [313]:frame=frame.set_index(['a','b'],append=True)In [314]:frameOut[314]:           c    dc a   bz bar one  z  1.0y bar two  y  2.0x foo one  x  3.0w foo two  w  4.0

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

In [315]:data.set_index('c',drop=False)Out[315]:     a    b  c    dcz  bar  one  z  1.0y  bar  two  y  2.0x  foo  one  x  3.0w  foo  two  w  4.0In [316]:data.set_index(['a','b'],inplace=True)In [317]:dataOut[317]:         c    da   bbar one  z  1.0    two  y  2.0foo one  x  3.0    two  w  4.0

Reset the index

As a convenience, there is a new function on DataFrame calledreset_indexwhich transfers the index values into the DataFrame’s columns and sets a simpleinteger index. This is the inverse operation toset_index

In [318]:dataOut[318]:         c    da   bbar one  z  1.0    two  y  2.0foo one  x  3.0    two  w  4.0In [319]:data.reset_index()Out[319]:     a    b  c    d0  bar  one  z  1.01  bar  two  y  2.02  foo  one  x  3.03  foo  two  w  4.0

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

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

In [320]:frameOut[320]:           c    dc a   bz bar one  z  1.0y bar two  y  2.0x foo one  x  3.0w foo two  w  4.0In [321]:frame.reset_index(level=1)Out[321]:         a  c    dc bz one  bar  z  1.0y two  bar  y  2.0x one  foo  x  3.0w two  foo  w  4.0

reset_index takes an optional parameterdrop which if true simplydiscards the index, instead of putting index values in the DataFrame’s columns.

Note

Thereset_index method used to be calleddelevel which is nowdeprecated.

Adding an ad hoc index

If you create an index yourself, you can just assign it to theindex field:

data.index=index

Returning a view versus a copy

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

In [322]:dfmi=pd.DataFrame([list('abcd'),   .....:list('efgh'),   .....:list('ijkl'),   .....:list('mnop')],   .....:columns=pd.MultiIndex.from_product([['one','two'],   .....:['first','second']]))   .....:In [323]:dfmiOut[323]:    one          two  first second first second0     a      b     c      d1     e      f     g      h2     i      j     k      l3     m      n     o      p

Compare these two access methods:

In [324]:dfmi['one']['second']Out[324]:0    b1    f2    j3    nName: second, dtype: object
In [325]:dfmi.loc[:,('one','second')]Out[325]:0    b1    f2    j3    nName: (one, second), dtype: object

These both yield the same results, so which should you use? It is instructive to understand the orderof 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 DataFrame that is singly-indexed.Then another python operationdfmi_with_one['second'] selects the series indexed by'second' happens.This is indicated by the variabledfmi_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 todf.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 operationscan be significantlyfaster, and allows one to indexboth axes if so desired.

Why does assignment fail when using chained indexing?

The problem in the previous section is just a performance issue. What’s up withtheSettingWithCopy warning? We don’tusually throw warnings around whenyou do something that might cost a few extra milliseconds!

But it turns out that assigning to the product of chained indexing hasinherently unpredictable results. To see this, think about how the Pythoninterpreter executes this code:

dfmi.loc[:,('one','second')]=value# becomesdfmi.loc.__setitem__((slice(None),('one','second')),value)

But this code is handled differently:

dfmi['one']['second']=value# becomesdfmi.__getitem__('one').__setitem__('second',value)

See that__getitem__ in there? Outside of simple cases, it’s very hard topredict whether it will return a view or a copy (it depends on the memory layoutof the array, about whichpandas makes no guarantees), and therefore whetherthe__setitem__ will modifydfmi or a temporary object that gets thrownout immediately afterward.That’s whatSettingWithCopy is warning youabout!

Note

You may be wondering whether we should be concerned about thelocproperty in the first example. Butdfmi.loc is guaranteed to bedfmiitself with modified indexing behavior, sodfmi.loc.__getitem__ /dfmi.loc.__setitem__ operate ondfmi directly. Of course,dfmi.loc.__getitem__(idx) may be a view or a copy ofdfmi.

Sometimes aSettingWithCopy warning will arise at times when there’s noobvious chained indexing going on.These are the bugs thatSettingWithCopy is designed to catch! Pandas is probably trying to warn youthat you’ve done this:

defdo_something(df):foo=df[['bar','baz']]# Is foo a view? A copy? Nobody knows!# ... many lines here ...foo['quux']=value# We don't know whether this will modify df or not!returnfoo

Yikes!

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 aSettingWithCopyexception 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 optionmode.chained_assignment,which can take the values['raise','warn',None], where showing a warning is the default.

In [326]:dfb=pd.DataFrame({'a':['one','one','two',   .....:'three','two','one','six'],   .....:'c':np.arange(7)})   .....:# This will show the SettingWithCopyWarning# but the frame values will be setIn [327]: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']=42Traceback (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 [328]:dfc=pd.DataFrame({'A':['aaa','bbb','ccc'],'B':[1,2,3]})In [329]:dfc.loc[0,'A']=11In [330]:dfcOut[330]:     A  B0   11  11  bbb  22  ccc  3

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

In [331]:dfc=dfc.copy()In [332]:dfc['A'][0]=111In [333]:dfcOut[333]:     A  B0  111  11  bbb  22  ccc  3

This willnot work at all, and so should be avoided

>>>pd.set_option('mode.chained_assignment','raise')>>>dfc.loc[0]['A']=1111Traceback (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 invalidassignment. There may be false positives; situations where a chained assignment is inadvertentlyreported.

Navigation

Scroll To Top
[8]ページ先頭
©2009-2025 Movatter.jp