ó šxŠ\c@sªddlZddlZddlZddlmZddljZddlmZm Z ddl m Z ddl m Z ddlmZmZmZmZmZmZmZmZmZddlmZmZmZddlmZmZddlj j!Z"dd l#m$Z$m%Z%d „Z&e'e(e(ƒZ)d e*fd „ƒYZ+e+ƒZ,d e-fd„ƒYZ.defd„ƒYZ/de/fd„ƒYZ0de/fd„ƒYZ1de1fd„ƒYZ2de1fd„ƒYZ3de/fd„ƒYZ4de4fd„ƒYZ5de4fd„ƒYZ6e(d„Z7d „Z8d!„Z9d"„Z:d#„Z;d$„Z<d%„Z=d&„Z>d'„Z?d(„Z@d)„ZAd*„ZBd+„ZCd,„ZDd-„ZEeFd.„ZGdS(/iÿÿÿÿN(t_NDFrameIndexerBase(trangetzip(tAbstractMethodError(tAppender( tensure_platform_inttis_floatt is_integertis_integer_dtypet is_iteratort is_list_liket is_scalart is_sequencet is_sparse(t ABCDataFrametABCPanelt ABCSeries(t_infer_fill_valuetisna(tIndext MultiIndexcCs1dtfdtfdtfdtfdtfgS(Ntixtiloctloctattiat(t _IXIndexert _iLocIndexert _LocIndexert _AtIndexert _iAtIndexer(((s3lib/python2.7/site-packages/pandas/core/indexing.pytget_indexers_lists     t _IndexSlicecBseZdZd„ZRS(s Create an object to more easily perform multi-index slicing See Also -------- MultiIndex.remove_unused_levels : New MultiIndex with no unused levels. Notes ----- See :ref:`Defined Levels ` for further info on slicing a MultiIndex. Examples -------- >>> midx = pd.MultiIndex.from_product([['A0','A1'], ['B0','B1','B2','B3']]) >>> columns = ['foo', 'bar'] >>> dfmi = pd.DataFrame(np.arange(16).reshape((len(midx), len(columns))), index=midx, columns=columns) Using the default slice command: >>> dfmi.loc[(slice(None), slice('B0', 'B1')), :] foo bar A0 B0 0 1 B1 2 3 A1 B0 8 9 B1 10 11 Using the IndexSlice class for a more intuitive command: >>> idx = pd.IndexSlice >>> dfmi.loc[idx[:, 'B0':'B1'], :] foo bar A0 B0 0 1 B1 2 3 A1 B0 8 9 B1 10 11 cCs|S(N((tselftarg((s3lib/python2.7/site-packages/pandas/core/indexing.pyt __getitem__Qs(t__name__t __module__t__doc__R#(((s3lib/python2.7/site-packages/pandas/core/indexing.pyR (s't IndexingErrorcBseZRS((R$R%(((s3lib/python2.7/site-packages/pandas/core/indexing.pyR'Xst_NDFrameIndexercBsˆeZeZeZeZed„Zd„Zd„Z ed„Z ed„Z eed„Z d„Z d„Zd„Zd „Zd „Zed „Zed „Zd „Zd„Zd„Zd„Zd„Zed„Zd„Zd„Zd„Zd„Zd„Zed„Z d„Z!d„Z"d„Z#ed„Z$ed„Z%ed„Z&ed„Z'eeed „Z(d!„Z)ed"„Z*RS(#cCsF|j|j|jƒ}|dk r9|jj|ƒ}n||_|S(N(t __class__tnametobjtNonet_get_axis_numbertaxis(R!R.tnew_self((s3lib/python2.7/site-packages/pandas/core/indexing.pyt__call__as   cCstdƒ‚dS(Nsix is not iterable(tNotImplementedError(R!((s3lib/python2.7/site-packages/pandas/core/indexing.pyt__iter__jscs°t|ƒtkrut‡fd†|Dƒƒ}y&ˆjj|Œ}t|ƒrS|SWntk rgnXˆj|ƒSˆjpd}tj |ˆjƒ}ˆj |d|ƒSdS(Nc3s$|]}tj|ˆjƒVqdS(N(tcomtapply_if_callableR+(t.0tx(R!(s3lib/python2.7/site-packages/pandas/core/indexing.pys osiR.( ttypettupleR+t _get_valueR t Exceptiont_getitem_tupleR.R3R4t _getitem_axis(R!tkeytvaluesR.((R!s3lib/python2.7/site-packages/pandas/core/indexing.pyR#ms    cCsŠ|dkr|jpd}n|jdkrC|jj|d|ƒSt|tƒrtt||tƒrttdƒ‚n|jj|d|ƒS(NiiR.s no slices here, handle elsewhere( R,R.tndimR+t_xst isinstanceR8tsliceR'(R!tlabelR.((s3lib/python2.7/site-packages/pandas/core/indexing.pyt _get_label€s "cCs.|dkr|j}n|jj|d|ƒS(NR.(R,R.R+t_ixs(R!R=R.((s3lib/python2.7/site-packages/pandas/core/indexing.pyt_get_locs  cCs4|dkr|j}n|jj|d|d|ƒS(NR.tkind(R,R.R+t_slice(R!R+R.RG((s3lib/python2.7/site-packages/pandas/core/indexing.pyRH”s  cCs.|jdk r"|j|dtƒS|jjdƒ}t|tƒrz|jdkrzy|j |ƒSWqzt k rvqzXnt|t ƒr·y|j|dtƒSWq·t k r³q·Xnt|t ƒrÙ|j|dtƒSy|j|dtƒSWn7tk r)}dt|ƒkr‚nt |ƒ‚nXdS(Nt is_setteriRs cannot do(R.R,t_convert_tupletTrueR+t _get_axisRARR*tget_locR:R8R'Rt_convert_ranget_convert_to_indexert TypeErrortstr(R!R=R.te((s3lib/python2.7/site-packages/pandas/core/indexing.pyt_get_setitem_indexer™s*  csft|tƒr.t‡fd†|Dƒƒ}ntj|ˆjƒ}ˆj|ƒ}ˆj||ƒdS(Nc3s$|]}tj|ˆjƒVqdS(N(R3R4R+(R5R6(R!(s3lib/python2.7/site-packages/pandas/core/indexing.pys ¹s(RAR8R3R4R+RSt_setitem_with_indexer(R!R=tvaluetindexer((R!s3lib/python2.7/site-packages/pandas/core/indexing.pyt __setitem__·s cCs tƒ‚dS(sõ Ensure that key is valid for current indexer. Parameters ---------- key : scalar, slice or list-like The key requested axis : int Dimension on which the indexing is being made Raises ------ TypeError If the key (or some element of it) has wrong type IndexError If the key (or some element of it) is out of bounds KeyError If the key was not found N(R(R!R=R.((s3lib/python2.7/site-packages/pandas/core/indexing.pyt _validate_keyÀscCs…x~t|ƒD]p\}}||jjkr:tdƒ‚ny|j||ƒWq tk r|tdjd|jƒƒ‚q Xq WdS(s0 check the key for valid keys across my indexer sToo many indexerss5Location based indexing can only have [{types}] typesttypesN(t enumerateR+R?R'RXt ValueErrortformatt _valid_types(R!R=titk((s3lib/python2.7/site-packages/pandas/core/indexing.pyt_has_valid_tupleÙs  cs@td„|jjDƒƒr<t‡fd†|jjDƒƒStS(Ncss|]}t|tƒVqdS(N(RAR(R5tax((s3lib/python2.7/site-packages/pandas/core/indexing.pys æsc3s|]}tˆ|ƒVqdS(N(tis_nested_tuple(R5Ra(ttup(s3lib/python2.7/site-packages/pandas/core/indexing.pys çs(tanyR+taxestFalse(R!Rc((Rcs3lib/python2.7/site-packages/pandas/core/indexing.pyt_is_nested_tuple_indexerås cCsûg}|jdk r‹|jj|jƒ}xÄt|jƒD]J}||krq|j|j|d|d|ƒƒq:|jtdƒƒq:Wnfxct |ƒD]U\}}||jjkrÅt dƒ‚n|j|d|d|ƒ}|j|ƒq˜Wt |ƒS(NR.RIsToo many indexers( R.R,R+R-RR?tappendRORBRZR'R8(R!R=RItkeyidxR.R^R_tidx((s3lib/python2.7/site-packages/pandas/core/indexing.pyRJês  cCs t|ƒS(s convert a range argument (tlist(R!R=RI((s3lib/python2.7/site-packages/pandas/core/indexing.pyRNüscCsM|dkrd}n|jjt||jdƒƒ}|j|d|jƒS(NiiRG(R,R+RLtminR?t_convert_scalar_indexerR*(R!R=R.Ra((s3lib/python2.7/site-packages/pandas/core/indexing.pyRms  "cCs8|jjt||jdƒƒ}|j|d|jƒS(NiRG(R+RLRlR?t_convert_slice_indexerR*(R!R=R.Ra((s3lib/python2.7/site-packages/pandas/core/indexing.pyRns"cCstS(N(RK(R!RV((s3lib/python2.7/site-packages/pandas/core/indexing.pyt_has_valid_setitem_indexer scCst|tƒr*tdj|jƒƒ‚nÔt|tƒsK|j|ƒ}nx°t|jj |ƒD]™\}}t|t ƒrqat |ƒrŽqat |ƒrÍ|t |ƒkrútdjd|jƒƒ‚qúqat|tƒratdjd|jƒƒ‚qaqaWtS(sŒ validate that an positional indexer cannot enlarge its target will raise if needed, does not modify the indexer externally s${0} cannot enlarge its target objects'{name} cannot enlarge its target objectR*(RAtdictt IndexErrorR\R*R8t_tuplifyRR+ReRBtis_list_like_indexerRtlenRK(R!RVRaR^((s3lib/python2.7/site-packages/pandas/core/indexing.pyt%_has_valid_positional_setitem_indexers$ "    c sQ ˆj|ƒddlm}ˆjj‰ˆjj}| r©ˆjjjr©ˆjjj\}d|jkr©t ˆt ƒrt ˆj ƒƒnˆ}|j |ƒ }q©nt |tƒr4t|ƒtˆjjƒkr4x[t|ˆjjƒD]A\}}t |tƒrìt|ƒptj|ƒ rìt}PqìqìWnt |tƒrg} x­t|ƒD]Ÿ\}} t | t ƒrèt| ƒ\} } ˆjdkre|ˆjjkregtˆjjƒD]$\} }| |kr·t|ƒ^q·}td„|Dƒƒr&tˆƒstdƒ‚nˆˆj| <ˆjStˆƒˆj| dt| gƒdˆƒ|_|ˆj|d|dˆƒˆj_ˆjj"dtƒdS(Niÿÿÿÿ(tSeriesicss|] }| VqdS(N((R5tl((s3lib/python2.7/site-packages/pandas/core/indexing.pys bss5cannot set a frame with no defined index and a scalarR.tcleartindexR*is*cannot set a frame with no defined columnstcopys(cannot set a row with mismatched columnsiisWcannot set using a multi-index selection indexer with a different length than the valueR>RVRUcs²ˆj|}ˆdkr#ˆdnˆ}t|tƒr]t‡fd†|Dƒƒr]|}nD|jƒ|jƒ}|jjd|d|ƒ|_|jdt ƒ|ˆj|sRVRURx( R+RAR8tallt_consolidate_inplaceRzt_datatsetitemt_maybe_update_cacherRK(titemtvtstpi(tlplane_indexert plane_indexerR!(s3lib/python2.7/site-packages/pandas/core/indexing.pytsetter s     cs‡tˆƒdk s3tjˆƒ s3tˆdƒr7tSˆd}ˆj|j}tˆƒ}t|ƒ|krstSˆ|krƒtStS(s. return True if we have an equal len settable ii(RttnptiterableR RfR+RyRK(R‚Ryt values_len(tlabelsR†R‡R!RU(s3lib/python2.7/site-packages/pandas/core/indexing.pytcan_do_equal_len!s#   R?tdtypes?Must have equal len keys and value when setting with an ndarrays@Must have equal len keys and value when setting with an iterablec3s0|]&\}}|ˆkrtj|ƒVqdS(N(R3R{(R5R^Rj(t info_axis(s3lib/python2.7/site-packages/pandas/core/indexing.pys ws (KRotpandasRvR+t_info_axis_numbert_is_mixed_typeRtblocksR?RARpRkR>t_can_hold_elementR8RtReRRRR3R{RKRZtconvert_missing_indexerRdRsR[Rt"convert_from_missing_indexer_tupleRTRLtinserttreindexRR,t_is_copyRhRMRyt is_uniquet get_indexert_valuesR‰t concatenateRPtastypetobjectt _constructorR*tcolumnsRWRrRt _align_seriestlength_of_indexerRŠtgetattrtravelRnR~RzR€Rtnanthasattrtarraytshapettolisttmaybe_convert_ixR}t _align_frameRt _align_panelt%_check_is_chained_assignment_possible( R!RVRURvttake_split_pathtblktvalR^RatnindexerRjR=t_t_it_axtlen_non_info_axest new_indexerRytmissingt new_indext new_valuestas_objt item_labelstinfo_idxR‚R+t plane_axisRˆRt sub_indexertmultiindex_indexerRƒ((RRŒR†R‡R!RUs3lib/python2.7/site-packages/pandas/core/indexing.pyRT+sP   !-" !  !        $        !          $      *      cCst|ttjttfƒr0t|gƒ}nt|tƒrÀd„}tt||ƒƒ}g|D]}tj |ƒ ^qd}t |ƒ}|dk}|j j dk} |j j dk} |j } | rÞ|oØ|d}n#| r|oû|dpû|d}n||j kržt d„|Dƒƒrž|j| jd|ddtƒj}t|ƒdkrš| ršt|dƒ} tj|| ƒj| dƒj}n|Sxlt|ƒD]\} }| j| }t|ƒsßt|tƒrj|rútj |ƒrúq«n||}t|ƒs"t|gƒ}n t|ƒ}|jj|ƒsMt|ƒ rZ|jjƒS|j|ƒjS|rÂ| rÂ|j jd}|jj|ƒs¥t|ƒ r²|jjƒS|j|ƒjS|r«g}xdt|j j| ƒƒD]J\}}t||j@ƒr|j|ƒ}qç|j|t|ƒfƒqçW|jjƒ}xP|D]H\}}dgt|ƒd}|||ËsRziÿÿÿÿs Incompatible indexer with SeriesN(!RARBR‰RÁRkRR8tmapR3R{tsumR+R?R}R˜ReRKRœRtttiletreshapetTRZR RsRytequalsRzt_get_plane_axesRhR RLR[(R!RVtserRÀR¥Rjtalignerst sum_alignerstsingle_alignertis_frametis_panelR+t len_indexerR^Ratnew_ixt broadcasttnRŒR.RwR©((s3lib/python2.7/site-packages/pandas/core/indexing.pyR¢“sx #   '$       %     c Cs|jjdk}|jjdk}t|tƒrÅd \}}g}x©t|ƒD]›\}} |jj|} t| ƒs‰t| tƒràt| t j ƒrª| j ƒ} n|dkrÃ| | }qí|dkrÜ| | }qíPqR|j |ƒqRW|rXt |ƒdkr%|ddkr%|j}n|dkr=|j}n|dkrX|j}qXn|dk rñ|dk rñ|jj|ƒr¦|jj|ƒr¦|jƒj} n|j|d|ƒj} | Sn,t|tƒsàt|ƒrx|rx|jj|} |jj| ƒr|jƒj} nZt| tƒr_t|jtƒr_| j|jjkr_tdƒ‚n|jd| ƒj} | St|ƒrñ|rñ|jjd}|jjd}|j|jƒrÛ|j|jƒrÛ|jƒjS|j|d|ƒjStdƒ‚dS( NiiiiR¡sAcannot align on a multi-index with out specifying the join levelsRys#Incompatible indexer with DataFrame(NN(R+R?RAR8R,RZReR RBR‰RÁR¥RhRtRÆRyR¡RÇRzRœR˜RsRtnlevelsRPR R[( R!RVtdfRÍRÎRjtcolst sindexersR^RRaR±((s3lib/python2.7/site-packages/pandas/core/indexing.pyR¬s\     "    $$ cCstdƒ‚dS(Ns-cannot set using an indexer with a Panel yet!(R1(R!RVRÔ((s3lib/python2.7/site-packages/pandas/core/indexing.pyR­^scCsÏy|j|ƒSWntk r$nX|j|ƒ|j|ƒrN|j|ƒS|j}xqt|ƒD]c\}}||jjkr‘tdƒ‚ntj |ƒr¦qdnt ||j ƒj |d|ƒ}qdW|S(NsToo many indexersR.( t_getitem_lowerdimR'R`t_multi_take_opportunityt _multi_takeR+RZR?R3R{R¤R*R<(R!RctretvalR^R=((s3lib/python2.7/site-packages/pandas/core/indexing.pyR;bs    %cCs8td„|DƒƒstStd„|Dƒƒr4tStS(sŒ Check whether there is the possibility to use ``_multi_take``. Currently the limit is that all axes being indexed must be indexed with list-likes. Parameters ---------- tup : tuple Tuple of indexers, one per axis Returns ------- boolean: Whether the current indexing can be passed through _multi_take css|]}t|ƒVqdS(N(Rs(R5R6((s3lib/python2.7/site-packages/pandas/core/indexing.pys ‹scss|]}tj|ƒVqdS(N(R3tis_bool_indexer(R5R6((s3lib/python2.7/site-packages/pandas/core/indexing.pys s(R}RfRdRK(R!Rc((s3lib/python2.7/site-packages/pandas/core/indexing.pyRØ|s csDˆj}‡fd†t||jƒDƒ}|j|dtdtƒS(s© Create the indexers for the passed tuple of keys, and execute the take operation. This allows the take operation to be executed all at once - rather than once for each dimension - improving efficiency. Parameters ---------- tup : tuple Tuple of indexers, one per axis Returns ------- values: same type as the object being indexed cs+i|]!\}}ˆj||ƒ|“qS((t_get_listlike_indexer(R5R=R.(R!(s3lib/python2.7/site-packages/pandas/core/indexing.pys ¥s Rzt allow_dups(R+Rt _AXIS_ORDERSt_reindex_with_indexersRK(R!Rctotd((R!s3lib/python2.7/site-packages/pandas/core/indexing.pyRÙ”s  cCs|S(N((R!R=R.((s3lib/python2.7/site-packages/pandas/core/indexing.pyt_convert_for_reindex©scCs–y|j|d|jƒSWnutk r-netk r‘}t|dttfƒrdtdƒ‚n|jj dƒ}|j |ƒs’|‚q’nXdS(NR.isHandle elsewhere( RDR.RPR:RARBRR'R+RLtis_lexsorted_for_tupleR,(R!Rcte1tax0((s3lib/python2.7/site-packages/pandas/core/indexing.pyt"_handle_lowerdim_multi_index_axis0¬s  c Cs|jdk r7|jj|jƒ}|j|d|ƒS|j|ƒrS|j|ƒS|jjdƒ}t|t ƒr¥|j dkr¥|j |ƒ}|dk r¥|Snt |ƒ|jj krÌtdƒ‚nx/t|ƒD]!\}}t|ƒst|tƒrÙ|j|d|ƒ}t|ƒs%|S|j |j krW|| tf||d}n||| ||d}t|tƒrµ|dkrµt |ƒdkrµ|\} } | | f}nt |ƒdkrÓ|\}ntj|ƒræ|St||j ƒ|SqÙWtdƒ‚dS(NR.iRs#Too many indexers. handle elsewhereiisnot applicable(R.R,R+R-R<Rgt_getitem_nested_tupleRLRARR*RæRtR?R'RZt is_label_likeR8Rst_NSRR3R{R¤( R!RcR.RåtresultR^R=tsectiontnew_keytatb((s3lib/python2.7/site-packages/pandas/core/indexing.pyR×Às<      cCs<t|ƒ|jkrJ|j|ƒ}|dk r4|S|j|d|jƒS|j}d}xÜt|ƒD]Î\}}tj |ƒr‘|d7}qfn|j}t ||j ƒj|d|ƒ}|d7}t |ƒsát |dƒ råPn|j|krf|dkr'|dkr'|jdkr'|j}n|d8}qfqfW|S(NR.iiR?ii(RtR?RæR,R<R.R+RZR3R{R¤R*R R§RÆ(R!RcRêR+R.R^R=t current_ndim((s3lib/python2.7/site-packages/pandas/core/indexing.pyRçýs*    ! ' cCs¸|dkr|jpd}nt|ƒr9t|ƒ}n|j||ƒ|jj|ƒ}t|tƒr}|j |d|ƒSt |ƒrèt|t ƒo¤t|t ƒ rèt |dƒrÕ|jdkrÕtdƒ‚n|j|d|ƒS|j|ƒ}t|ƒr¡|dkrqt|t ƒrqy|j|d|ƒSWqqttfk rm|jjjdjƒrn‚qnqqXn|jƒ r¡|jƒ r¡|j|d|ƒSn|j|d|ƒSdS(NiR.R?is&Cannot index with multidimensional key(R,R.R RkRXR+RLRARBt_get_slice_axisRsR8RR§R?R[t_getitem_iterablet_maybe_cast_indexerRRDtKeyErrorRPRytlevelst is_floatingRF(R!R=R.RŒ((s3lib/python2.7/site-packages/pandas/core/indexing.pyR<-s2     c Cs|j}|j|ƒ}|j|d|jƒ\}}|dk r{|dkjƒr{|j|||d|ƒ|||fS|jr×t|ƒst|ƒ r²|j ||ƒ}n|j |ƒ}|j |ƒd}n|j |ƒ\}}}|j|||j |ƒd|ƒ||fS(sE Transform a list-like of keys into a new index and an indexer. Parameters ---------- key : list-like Target labels axis: int Dimension on which the indexing is being made raise_missing: bool Whether to raise a KeyError if some labels are not found. Will be removed in the future, and then this method will always behave as if raise_missing=True. Raises ------ KeyError If at least one key was requested but none was found, and raise_missing=True. Returns ------- keyarr: Index New index (coinciding with 'key' if the axis is unique) values : array-like An indexer for the return object; -1 denotes keys not found RGiÿÿÿÿt raise_missingiN(R+RLt_convert_listlike_indexerR*R,R}t_validate_read_indexerRšRtRâtget_indexer_forR˜t_reindex_non_uniqueR-( R!R=R.RöRàRaRVtkeyarrR·((s3lib/python2.7/site-packages/pandas/core/indexing.pyRÜTs$    cCsÎ|dkr|jpd}n|j||ƒ|jj|ƒ}tj|ƒrƒt||ƒ}|jƒ\}|jj |d|ƒS|j ||dt ƒ\}}|jj i||g|6dt dt ƒSdS(s¯ Index current object with an an iterable key (which can be a boolean indexer, or a collection of keys). Parameters ---------- key : iterable Target labels, or boolean indexer axis: int, default None Dimension on which the indexing is being made Raises ------ KeyError If no key was found. Will change in the future to raise if not all keys were found. IndexingError If the boolean indexer is unalignable with the object being indexed. Returns ------- scalar, DataFrame, or Series: indexed value(s), iR.RöRzRÝN(R,R.RXR+RLR3RÛtcheck_bool_indexertnonzerot_takeRÜRfRßRK(R!R=R.RŒtindsRûRV((s3lib/python2.7/site-packages/pandas/core/indexing.pyRñŒs c Cs|jj|ƒ}t|ƒdkr(dS|dkjƒ}|r |t|ƒkrtdjd|d|jj|ƒƒƒ‚n|jdko’| sÉtt |ƒt |ƒƒ}tdj|ƒƒ‚nt j dƒ}|j ƒpí|j ƒs tj|td d ƒq ndS( sR Check that indexer can be used to return a result (e.g. at least one element was found, unless the list of keys was actually empty). Parameters ---------- key : list-like Target labels (only used to show correct error message) indexer: array-like of booleans Indices corresponding to the key (with -1 indicating not found) axis: int Dimension on which the indexing is being made raise_missing: bool Whether to raise a KeyError if some labels are not found. Will be removed in the future, and then this method will always behave as if raise_missing=True. Raises ------ KeyError If at least one key was requested but none was found, and raise_missing=True. iNu#None of [{key}] are in the [{axis}]R=R.Rs{} not in indexs, Passing list-likes to .loc or [] with any missing label will raise KeyError in the future, you can use .reindex() as an alternative. See the documentation here: https://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate-loc-reindex-listliket stackleveli(R+RLRtRÃRóR\t_get_axis_nameR*Rktsetttextwraptdedenttis_categoricalt is_intervaltwarningstwarnt FutureWarning( R!R=RVR.RöRaR¸t not_foundt_missing_key_warning((s3lib/python2.7/site-packages/pandas/core/indexing.pyRø¹s" !  c Cst|dkr|jpd}n|jj|ƒ}t|tƒrO|j||ƒSy|j||ƒ}Wntk r|r‚q‚nX|j ƒ}t |ƒož| }y|j |ƒSWn‡t k rt|t ƒr<t|t ƒr<|rt|ƒ|jkri|d6S‚q<n-tk rntk r;|s<‚q<nX|rž|rš|jdkrbi|d6S||jj|kršt|t ƒ rštdƒ‚qšn|St||ƒrº|j|ƒSt|ƒr*tj|ƒr÷t||ƒ}|jƒ\}|Si|rtn|d6} |j||| dSnFy|j |ƒSWn2t k rot|ƒ ri|rii|d6S‚nXdS(sÑ Convert indexing key into something we can use to do actual fancy indexing on an ndarray Examples ix[:5] -> slice(0, 5) ix[[1,2,3]] -> [1,2,3] ix[['foo', 'bar', 'baz']] -> [i, j, k] (indices of foo, bar, baz) Going by Zen of Python? 'In the face of ambiguity, refuse the temptation to guess.' raise AmbiguousIndexError with integer labels? - No, prefer label-based indexing iR=Rs2cannot set by positional indexing with enlargementRöiN(R,R.R+RLRARBRnRmRPRRMt LookupErrorR8RRtRÓR[R*R©Rbtget_locsRsR3RÛRüRýRKRÜ( R!R+R.RIRöRŒt is_int_indextis_int_positionalRÿtkwargs((s3lib/python2.7/site-packages/pandas/core/indexing.pyRO÷s`               cCs?gt|jƒD]}tddƒ^q}||d \ RcBsMeZdZejdƒZd„Zeej jƒd„ƒZ dd„Z RS(s£A primarily label-location based indexer, with integer position fallback. Warning: Starting in 0.20.0, the .ix indexer is deprecated, in favor of the more strict .iloc and .loc indexers. ``.ix[]`` supports mixed integer and label based access. It is primarily label based, but will fall back to integer positional access unless the corresponding axis is of integer type. ``.ix`` is the most general indexer and will support any of the inputs in ``.loc`` and ``.iloc``. ``.ix`` also supports floating point label schemes. ``.ix`` is exceptionally useful when dealing with mixed positional and label based hierarchical indexes. However, when an axis is integer based, ONLY label 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 at :ref:`Advanced Indexing `. sõ .ix is deprecated. Please use .loc for label based indexing or .iloc for positional indexing See the documentation here: http://pandas.pydata.org/pandas-docs/stable/indexing.html#ix-indexer-is-deprecatedcCs6tj|jtddƒtt|ƒj||ƒdS(NRi(RRt_ix_deprecation_warningtDeprecationWarningtsuperRt__init__(R!R*R+((s3lib/python2.7/site-packages/pandas/core/indexing.pyRˆs  cCsJt|tƒrtStj|ƒr&tSt|ƒr6tS|j||ƒtS(N(RARBRKR3RÛRsRm(R!R=R.((s3lib/python2.7/site-packages/pandas/core/indexing.pyRXs cCsÍ|dkr|jpd}n|jj|ƒ}tj|ƒrVt||ƒ}||St|tƒrw|j |ƒ}ntj |ƒ}t |ƒrÉ|j |ƒ}|j ƒsÉt|ƒ}|j|ƒSn|S(s` Transform a list of keys into a new array ready to be used as axis of the object we return (e.g. including NaNs). Parameters ---------- key : list-like Target labels axis: int Where the indexing is being made Returns ------- list-like of labels iN(R,R.R+RLR3RÛRüRARt_convert_index_indexertasarray_tuplesafeRt_convert_arr_indexerRRttake(R!R=R.RŒRû((s3lib/python2.7/site-packages/pandas/core/indexing.pyRâžs    N( R$R%R&RRRRRR(RXR,Râ(((s3lib/python2.7/site-packages/pandas/core/indexing.pyRis   t_LocationIndexercBsMeZeZd„Zd„Zd„Zdd„Zdd„Z dd„Z RS(cs³t|ƒtkrxt‡fd†|Dƒƒ}y ˆj|ƒrMˆj|ƒSWntttfk rjnXˆj|ƒSˆjp„d}t j |ˆj ƒ}ˆj |d|ƒSdS(Nc3s$|]}tj|ˆjƒVqdS(N(R3R4R+(R5R6(R!(s3lib/python2.7/site-packages/pandas/core/indexing.pys ÏsiR.( R7R8t_is_scalar_accesst_getitem_scalarRóRqtAttributeErrorR;R.R3R4R+R<(R!R=R.tmaybe_callable((R!s3lib/python2.7/site-packages/pandas/core/indexing.pyR#Ís  cCs tƒ‚dS(N(R1(R!R=((s3lib/python2.7/site-packages/pandas/core/indexing.pyRÞscCs tƒ‚dS(N(R1(R!R=((s3lib/python2.7/site-packages/pandas/core/indexing.pyRáscCs tƒ‚dS(N(R1(R!R=R.((s3lib/python2.7/site-packages/pandas/core/indexing.pyR<äscCs‘|dkr|jpd}n|jj|ƒ}t||ƒ}|jƒ\}y|jj|d|ƒSWn"tk rŒ}|j|ƒ‚nXdS(NiR.( R,R.R+RLRüRýRþR:R(R!R=R.RŒRÿtdetail((s3lib/python2.7/site-packages/pandas/core/indexing.pyt _getbool_axisçs cCs»|dkr|jpd}n|j}t|ƒsC|jdtƒS|j|ƒ}|j|j|j |j d|j ƒ}t |t ƒr¡|j|d|ddƒS|jj|d|ƒSdS(s; this is pretty simple as we just have to deal with labels iRRGR.RN(R,R.R+RRzRfRLt slice_indexertstarttstoptstepR*RARBRHRþ(R!RR.R+RŒRV((s3lib/python2.7/site-packages/pandas/core/indexing.pyRðòs   N( R$R%R:RR#RRR,R<R#Rð(((s3lib/python2.7/site-packages/pandas/core/indexing.pyRÊs     RcBs\eZdZdZeZeejjƒd„ƒZd„Z d„Z d„Z dd„Z RS(sS Access a group of rows and columns by label(s) or a boolean array. ``.loc[]`` is primarily label based, but may also be used with a boolean array. Allowed inputs are: - A single label, e.g. ``5`` or ``'a'``, (note that ``5`` is interpreted as a *label* of the index, and **never** as an integer position along the index). - A list or array of labels, e.g. ``['a', 'b', 'c']``. - A slice object with labels, e.g. ``'a':'f'``. .. warning:: Note that contrary to usual python slices, **both** the start and the stop are included - A boolean array of the same length as the axis being sliced, e.g. ``[True, False, True]``. - A ``callable`` function with one argument (the calling Series, DataFrame or Panel) and that returns valid output for indexing (one of the above) See more at :ref:`Selection by Label ` Raises ------ KeyError: when any items are not found See Also -------- DataFrame.at : Access a single value for a row/column label pair. DataFrame.iloc : Access group of rows and columns by integer position(s). DataFrame.xs : Returns a cross-section (row(s) or column(s)) from the Series/DataFrame. Series.loc : Access group of values using labels. Examples -------- **Getting values** >>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]], ... index=['cobra', 'viper', 'sidewinder'], ... columns=['max_speed', 'shield']) >>> df max_speed shield cobra 1 2 viper 4 5 sidewinder 7 8 Single label. Note this returns the row as a Series. >>> df.loc['viper'] max_speed 4 shield 5 Name: viper, dtype: int64 List of labels. Note using ``[[]]`` returns a DataFrame. >>> df.loc[['viper', 'sidewinder']] max_speed shield viper 4 5 sidewinder 7 8 Single label for row and column >>> df.loc['cobra', 'shield'] 2 Slice with labels for row and single label for column. As mentioned above, note that both the start and stop of the slice are included. >>> df.loc['cobra':'viper', 'max_speed'] cobra 1 viper 4 Name: max_speed, dtype: int64 Boolean list with the same length as the row axis >>> df.loc[[False, False, True]] max_speed shield sidewinder 7 8 Conditional that returns a boolean Series >>> df.loc[df['shield'] > 6] max_speed shield sidewinder 7 8 Conditional that returns a boolean Series with column labels specified >>> df.loc[df['shield'] > 6, ['max_speed']] max_speed sidewinder 7 Callable that returns a boolean Series >>> df.loc[lambda df: df['shield'] == 8] max_speed shield sidewinder 7 8 **Setting values** Set value for all items matching the list of labels >>> df.loc[['viper', 'sidewinder'], ['shield']] = 50 >>> df max_speed shield cobra 1 2 viper 4 50 sidewinder 7 50 Set value for an entire row >>> df.loc['cobra'] = 10 >>> df max_speed shield cobra 10 10 viper 4 50 sidewinder 7 50 Set value for an entire column >>> df.loc[:, 'max_speed'] = 30 >>> df max_speed shield cobra 30 10 viper 30 50 sidewinder 30 50 Set value for rows matching callable condition >>> df.loc[df['shield'] > 35] = 0 >>> df max_speed shield cobra 30 10 viper 0 0 sidewinder 0 0 **Getting values on a DataFrame with an index that has integer labels** Another example using integers for the index >>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]], ... index=[7, 8, 9], columns=['max_speed', 'shield']) >>> df max_speed shield 7 1 2 8 4 5 9 7 8 Slice with integer labels for rows. As mentioned above, note that both the start and stop of the slice are included. >>> df.loc[7:9] max_speed shield 7 1 2 8 4 5 9 7 8 **Getting values with a MultiIndex** A number of examples using a DataFrame with a MultiIndex >>> tuples = [ ... ('cobra', 'mark i'), ('cobra', 'mark ii'), ... ('sidewinder', 'mark i'), ('sidewinder', 'mark ii'), ... ('viper', 'mark ii'), ('viper', 'mark iii') ... ] >>> index = pd.MultiIndex.from_tuples(tuples) >>> values = [[12, 2], [0, 4], [10, 20], ... [1, 4], [7, 1], [16, 36]] >>> df = pd.DataFrame(values, columns=['max_speed', 'shield'], index=index) >>> df max_speed shield cobra mark i 12 2 mark ii 0 4 sidewinder mark i 10 20 mark ii 1 4 viper mark ii 7 1 mark iii 16 36 Single label. Note this returns a DataFrame with a single index. >>> df.loc['cobra'] max_speed shield mark i 12 2 mark ii 0 4 Single index tuple. Note this returns a Series. >>> df.loc[('cobra', 'mark ii')] max_speed 0 shield 4 Name: (cobra, mark ii), dtype: int64 Single label for row and column. Similar to passing in a tuple, this returns a Series. >>> df.loc['cobra', 'mark i'] max_speed 12 shield 2 Name: (cobra, mark i), dtype: int64 Single tuple. Note using ``[[]]`` returns a DataFrame. >>> df.loc[[('cobra', 'mark ii')]] max_speed shield cobra mark ii 0 4 Single tuple for the index with a single label for the column >>> df.loc[('cobra', 'mark i'), 'shield'] 2 Slice from index tuple to single label >>> df.loc[('cobra', 'mark i'):'viper'] max_speed shield cobra mark i 12 2 mark ii 0 4 sidewinder mark i 10 20 mark ii 1 4 viper mark ii 7 1 mark iii 16 36 Slice from index tuple to index tuple >>> df.loc[('cobra', 'mark i'):('viper', 'mark ii')] max_speed shield cobra mark i 12 2 mark ii 0 4 sidewinder mark i 10 20 mark ii 1 4 viper mark ii 7 1 sšlabels (MUST BE IN THE INDEX), slices of labels (BOTH endpoints included! Can be slices of integers if the index is integers), listlike of labels, booleancCsIt|tƒrdStj|ƒr&dSt|ƒsE|j||ƒndS(N(RARBR3RÛRsRm(R!R=R.((s3lib/python2.7/site-packages/pandas/core/indexing.pyRXøs  cCst|dƒstSt|ƒ|jkr,tSxZt|ƒD]L\}}t|ƒsUtS|jj|}t|t ƒrxtS|j s9tSq9Wt S(Nt__len__( R§RfRtR?RZR R+ReRARRšRK(R!R=R^R_Ra((s3lib/python2.7/site-packages/pandas/core/indexing.pyR s  cCs|jj|Œ}|S(N(R+R9(R!R=R>((s3lib/python2.7/site-packages/pandas/core/indexing.pyR!scCsôt|tƒrðt|tjƒra|jdjrat|gtdƒgt |jƒdƒ}nt|tƒrðg}xet |ƒD]W\}}t|tjƒrÍ|j|jrÍ|j t||dƒƒqƒ|j |ƒqƒWt|ƒ}qðn|S(s_Translate any partial string timestamp matches in key, returning the new key (GH 10331)iiN( RARtcompatt string_typesRôt is_all_datesR8RBR,RtRZRh(R!R=RŒRìR^t component((s3lib/python2.7/site-packages/pandas/core/indexing.pyt'_get_partial_string_timestamp_match_key's0cCsn|dkr|jpd}nt|ƒr9t|ƒ}n|jj|ƒ}|j||ƒ}t|tƒr|j ||ƒ|j |d|ƒSt j |ƒr±|j |d|ƒSt|ƒrKt|tƒr˜t|ttjfƒr|jdkrt|ƒ}nKt|tƒr tdƒ‚n-t|dƒrM|jdkrMtdƒ‚nt|tƒ r˜t|ƒdkr˜t|dtƒ r˜t|gƒ}q˜nt|tƒo³t|tƒsöt|dƒrã|jdkrãtdƒ‚n|j|d|ƒSt||ƒrK|j|ƒ}tdƒg|j}|||<|jjt|ƒSn|j ||ƒ|j|d|ƒS(NiR.is=Indexing a MultiIndex with a DataFrame key is not implementedR?sDIndexing a MultiIndex with a multidimensional key is not implementeds&Cannot index with multidimensional key(R,R.R RkR+RLR-RARBRXRðR3RÛR#RsRRR‰RÁR?RR1R§R8RtR[RñRbR RRD(R!R=R.RŒtlocsRV((s3lib/python2.7/site-packages/pandas/core/indexing.pyR<?sB   '" N(R$R%R&R]RóRRR(RXRRR-R,R<(((s3lib/python2.7/site-packages/pandas/core/indexing.pyRsì   RcBsƒeZdZdZeZd„Zd„Zd„Zd„Z d„Z d„Z d d„Z d d „Zd d „Zd ed „ZRS( sÍ Purely integer-location based indexing for selection by position. ``.iloc[]`` is primarily integer position based (from ``0`` to ``length-1`` of the axis), but may also be used with a boolean array. Allowed inputs are: - An integer, e.g. ``5``. - A list or array of integers, e.g. ``[4, 3, 0]``. - A slice object with ints, e.g. ``1:7``. - A boolean array. - A ``callable`` function with one argument (the calling Series, DataFrame or Panel) and that returns valid output for indexing (one of the above). This is useful in method chains, when you don't have a reference to the calling object, but would like to base your selection on some value. ``.iloc`` will raise ``IndexError`` if a requested indexer is out-of-bounds, except *slice* indexers which allow out-of-bounds indexing (this conforms with python/numpy *slice* semantics). See more at ref:`Selection by Position `. See Also -------- DataFrame.iat : Fast integer location scalar accessor. DataFrame.loc : Purely label-location based indexer for selection by label. Series.iloc : Purely integer-location based indexing for selection by position. Examples -------- >>> mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4}, ... {'a': 100, 'b': 200, 'c': 300, 'd': 400}, ... {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000 }] >>> df = pd.DataFrame(mydict) >>> df a b c d 0 1 2 3 4 1 100 200 300 400 2 1000 2000 3000 4000 **Indexing just the rows** With a scalar integer. >>> type(df.iloc[0]) >>> df.iloc[0] a 1 b 2 c 3 d 4 Name: 0, dtype: int64 With a list of integers. >>> df.iloc[[0]] a b c d 0 1 2 3 4 >>> type(df.iloc[[0]]) >>> df.iloc[[0, 1]] a b c d 0 1 2 3 4 1 100 200 300 400 With a `slice` object. >>> df.iloc[:3] a b c d 0 1 2 3 4 1 100 200 300 400 2 1000 2000 3000 4000 With a boolean mask the same length as the index. >>> df.iloc[[True, False, True]] a b c d 0 1 2 3 4 2 1000 2000 3000 4000 With a callable, useful in method chains. The `x` passed to the ``lambda`` is the DataFrame being sliced. This selects the rows whose index label even. >>> df.iloc[lambda x: x.index % 2 == 0] a b c d 0 1 2 3 4 2 1000 2000 3000 4000 **Indexing both axes** You can mix the indexer types for the index and columns. Use ``:`` to select the entire axis. With scalar integers. >>> df.iloc[0, 1] 2 With lists of integers. >>> df.iloc[[0, 2], [1, 3]] b d 0 2 4 2 2000 4000 With `slice` objects. >>> df.iloc[1:3, 0:3] a b c 1 100 200 300 2 1000 2000 3000 With a boolean array whose length matches the columns. >>> df.iloc[:, [True, False, True, False]] a c 0 1 3 1 100 300 2 1000 3000 With a callable function that expects the Series or DataFrame. >>> df.iloc[:, lambda df: [0, 2]] a c 0 1 3 1 100 300 2 1000 3000 slinteger, integer slice (START point is INCLUDED, END point is EXCLUDED), listlike of integers, boolean arraycCsItj|ƒrdt|dƒr`t|jtƒr`|jjdkrQtdƒ‚ntdƒ‚ndSt|t ƒrwdSt |ƒr–|j ||ƒn¯t|t ƒr´t dƒ‚n‘t|ƒr*tj|ƒ}t|jj|ƒƒ}t|ƒrE|jƒ|ks|jƒ| krEtdƒ‚qEntdjd|jƒƒ‚dS( NRytintegersDiLocation based boolean indexing on an integer type is not availablesBiLocation based boolean indexing cannot use an indexable as a masksToo many indexerss%positional indexers are out-of-boundss+Can only index by location with a [{types}]RY(R3RÛR§RARyRt inferred_typeR1R[RBRt_validate_integerR8R'RsR‰R¨RtR+RLtmaxRlRqR\R](R!R=R.tarrtlen_axis((s3lib/python2.7/site-packages/pandas/core/indexing.pyRXs&!  1 cCs|j|ƒdS(N(Ru(R!RV((s3lib/python2.7/site-packages/pandas/core/indexing.pyRo&scCszt|dƒstSt|ƒ|jkr,tSxGt|ƒD]9\}}t|ƒsUtS|jj|}|js9tSq9Wt S(NR(( R§RfRtR?RZRR+ReRšRK(R!R=R^R_Ra((s3lib/python2.7/site-packages/pandas/core/indexing.pyR)s  cCs|jjdt|Œ}|S(Nttakeable(R+R9RK(R!R=R>((s3lib/python2.7/site-packages/pandas/core/indexing.pyR>scCsDt|jj|ƒƒ}||ks1|| kr@tdƒ‚ndS(sk Check that 'key' is a valid position in the desired axis. Parameters ---------- key : int Requested position axis : int Desired axis Returns ------- None Raises ------ IndexError If 'key' is not a valid position in axis 'axis' s*single positional indexer is out-of-boundsN(RtR+RLRq(R!R=R.R4((s3lib/python2.7/site-packages/pandas/core/indexing.pyR1DscCsì|j|ƒy|j|ƒSWntk r1nX|j}d}x¤t|ƒD]–\}}||jjkr{tdƒ‚ntj|ƒrš|d7}qNnt||j ƒj |d|ƒ}|j|jkrÚ|d8}n|d7}qNW|S(NisToo many indexersiR.( R`R×R'R+RZR?R3R{R¤R*R<(R!RcRÚR.R^R=((s3lib/python2.7/site-packages/pandas/core/indexing.pyR;]s$    ! cCs—|dkr|jpd}n|j}t|ƒsC|jdtƒS|j||ƒ}t|tƒr}|j |d|ddƒS|jj |d|ƒSdS(NiRR.RGR( R,R.R+RRzRfRnRARBRHRþ(R!RR.R+((s3lib/python2.7/site-packages/pandas/core/indexing.pyRðzs   cCs\|dkr|jpd}ny|jj|d|ƒSWntk rWtdƒ‚nXdS(sò Return Series values by list or array of integers Parameters ---------- key : list-like positional indexer axis : int (can only be zero) Returns ------- Series object iR.s%positional indexers are out-of-boundsN(R,R.R+RþRq(R!R=R.((s3lib/python2.7/site-packages/pandas/core/indexing.pyt_get_list_axisˆs  cCsô|dkr|jpd}nt|tƒr@|j|d|ƒSt|tƒratj|ƒ}ntj |ƒr“|j ||ƒ|j |d|ƒSt |ƒr²|j |d|ƒSt|ƒsÍtdƒ‚n|j||ƒ|j|d|ƒSdS(NiR.s5Cannot index by location index with a non-integer key(R,R.RARBRðRkR‰tasarrayR3RÛRXR#RsR6RRPR1RF(R!R=R.((s3lib/python2.7/site-packages/pandas/core/indexing.pyR<s   cCs¤|dkr|jpd}nt|tƒr=|j||ƒSt|ƒrY|j||ƒSy|j||ƒ|SWn,tk rŸtdj d|j ƒƒ‚nXdS(s; much simpler as we only have to deal with our valid types is+Can only index by location with a [{types}]RYN( R,R.RARBRnRRmRXR[R\R](R!R+R.RI((s3lib/python2.7/site-packages/pandas/core/indexing.pyROºs    N(R$R%R&R]RqRRXRoRRR1R;R,RðR6R<RfRO(((s3lib/python2.7/site-packages/pandas/core/indexing.pyR|s†         t_ScalarAccessIndexercBs,eZdZed„Zd„Zd„ZRS(s access scalars quickly cCs t|ƒS(N(Rk(R!R=RI((s3lib/python2.7/site-packages/pandas/core/indexing.pyt _convert_keyÑscCsdt|tƒs<t|ƒs-t|gƒ}q<tdƒ‚n|j|ƒ}|jjd|j|ŒS(Ns)Invalid call for scalar access (getting)!R5(RAR8RsR[R9R+R9t _takeable(R!R=((s3lib/python2.7/site-packages/pandas/core/indexing.pyR#Ôs  csÐt|tƒr.t‡fd†|Dƒƒ}ntj|ˆjƒ}t|tƒsdˆj|ƒ}nt|ƒˆjjkr‹tdƒ‚nt ˆj |dt ƒƒ}|j |ƒˆjj dˆj|ŒdS(Nc3s$|]}tj|ˆjƒVqdS(N(R3R4R+(R5R6(R!(s3lib/python2.7/site-packages/pandas/core/indexing.pys âss0Not enough indexers for scalar access (setting)!RIR5(RAR8R3R4R+RrRtR?R[RkR9RKRht _set_valueR:(R!R=RU((R!s3lib/python2.7/site-packages/pandas/core/indexing.pyRWàs (R$R%R&RfR9R#RW(((s3lib/python2.7/site-packages/pandas/core/indexing.pyR8Îs  RcBs eZdZeZed„ZRS(sþ Access a single value for a row/column label pair. Similar to ``loc``, in that both provide label-based lookups. Use ``at`` if you only need to get or set a single value in a DataFrame or Series. Raises ------ KeyError When label does not exist in DataFrame See Also -------- DataFrame.iat : Access a single value for a row/column pair by integer position. DataFrame.loc : Access a group of rows and columns by label(s). Series.at : Access a single value using a label. Examples -------- >>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]], ... index=[4, 5, 6], columns=['A', 'B', 'C']) >>> df A B C 4 0 2 3 5 0 4 1 6 10 20 30 Get value at specified row/column pair >>> df.at[4, 'B'] 2 Set value at specified row/column pair >>> df.at[4, 'B'] = 10 >>> df.at[4, 'B'] 10 Get value within a Series >>> df.loc[5].at['B'] 4 cCsŒ|rt|ƒSxut|jj|ƒD]^\}}|jƒr\t|ƒs„tdƒ‚q„q&t|ƒr&|jƒ r&tdƒ‚q&q&W|S(s[ require they keys to be the same type as the index (so we don't fallback) sDAt based indexing on an integer index can only have integer indexerssLAt based indexing on an non-integer index can only have non-integer indexers(RkRR+ReRR[t holds_integer(R!R=RIRaR^((s3lib/python2.7/site-packages/pandas/core/indexing.pyR9# s "  (R$R%R&RfR:R9(((s3lib/python2.7/site-packages/pandas/core/indexing.pyRòs-RcBs)eZdZeZd„Zed„ZRS(s Access a single value for a row/column pair by integer position. Similar to ``iloc``, in that both provide integer-based lookups. Use ``iat`` if you only need to get or set a single value in a DataFrame or Series. Raises ------ IndexError When integer position is out of bounds See Also -------- DataFrame.at : Access a single value for a row/column label pair. DataFrame.loc : Access a group of rows and columns by label(s). DataFrame.iloc : Access a group of rows and columns by integer position(s). Examples -------- >>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]], ... columns=['A', 'B', 'C']) >>> df A B C 0 0 2 3 1 0 4 1 2 10 20 30 Get value at specified row/column pair >>> df.iat[1, 2] 1 Set value at specified row/column pair >>> df.iat[1, 2] = 10 >>> df.iat[1, 2] 10 Get value within a series >>> df.loc[0].iat[1] 2 cCs|j|ƒdS(N(Ru(R!RV((s3lib/python2.7/site-packages/pandas/core/indexing.pyRoi scCsEx>t|jj|ƒD]'\}}t|ƒstdƒ‚qqW|S(s7 require integer args (and convert to label arguments) s1iAt based indexing can only have integer indexers(RR+ReRR[(R!R=RIRíR^((s3lib/python2.7/site-packages/pandas/core/indexing.pyR9l s" (R$R%R&RKR:RoRfR9(((s3lib/python2.7/site-packages/pandas/core/indexing.pyR9 s, cCs1|dk rét|tƒrét|ƒ}|j}|j}|j}|dkrWd}n|dkrp||7}n|dksˆ||kr‘|}n|dkrª||7}n|dkr¿d}n|dkrÕ| }n|||d|St|ttt j t fƒrt|ƒSt |ƒs!dSt dƒ‚dS(sP return the length of a single non-tuple indexer which could be a slice iis%cannot find the length of the indexerN(R,RARBRtR%R&R'RRR‰RÁRkRstAssertionError(RVttargett target_lenR%R&R'((s3lib/python2.7/site-packages/pandas/core/indexing.pyR£u s.                 cCs˜|j}t|tƒr+|j|ddƒSt|tjƒr”|jjj|ƒrVdS|j r”y|j |ƒSWq‘t t tfk rdSXq”ndS(sQ if we are index sliceable, then return my slicer, otherwise return None RGtgetitemN(RyRARBRnR)R*RtitemstcontainsR,R+t_get_string_sliceRóR[R1(R+R=Rj((s3lib/python2.7/site-packages/pandas/core/indexing.pytconvert_to_index_sliceable’ s   cCs¿|}t|tƒrv|jj|ƒ rv|j|ƒ}t|jƒ}|jƒratdƒ‚n|j t ƒj}nEt |ƒr¦|j ƒ}t j|dt ƒ}nt j|dt ƒ}|S(NsrUnalignable boolean Series provided as indexer (index of the boolean Series and of the indexed object do not matchRŽ(RARRyRÇR˜RRœRdR'RžtboolR tto_denseR‰R7(RaR=Rêtmask((s3lib/python2.7/site-packages/pandas/core/indexing.pyRü« s"   cCsìt|tjtfƒr‘t|ƒrèt|ƒt|ƒkrèt|tjƒoy|jtjkoyt||ƒt|ƒksŽtdƒ‚qŽqènWt|t ƒrèt|ƒrèt|ƒrèt|ƒt ||ƒkråtdƒ‚qåqèndS(sW Validate that value and indexer are the same length. An special-case is allowed for when the indexer is a boolean array and the number of true values equals the length of ``value``. In this case, no exception is raised. Parameters ---------- indexer : sequence The key for the setitem value : array-like The value for the setitem values : array-like The values being set into Returns ------- None Raises ------ ValueError When the indexer is an ndarray or list and the lengths don't match. sKcannot set using a list-like indexer with a different length than the valuesGcannot set using a slice indexer with a different length than the valueN( RAR‰RÁRkR RtRŽtbool_R[RBR£(RVRUR>((s3lib/python2.7/site-packages/pandas/core/indexing.pytcheck_setitem_lengthsÅ s$cCsKt|tƒrA|d}t|tƒr7tdƒ‚n|tfS|tfS(sƒ reverse convert a missing indexer, which is a dict return the scalar indexer and a boolean indicating if we converted R=s.cannot use a single bool to index into setitem(RARpRERóRKRf(RV((s3lib/python2.7/site-packages/pandas/core/indexing.pyR•ñ s   cs/‡fd†‰t‡fd†t|ƒDƒƒS(sJ create a filtered indexer that doesn't have any missing indexers cs(t|tƒr$ˆ|j|dƒS|S(NR=(RARpRM(R´t_idx(Re(s3lib/python2.7/site-packages/pandas/core/indexing.pyR› s$c3s$|]\}}ˆ||ƒVqdS(N((R5R´RJ(R›(s3lib/python2.7/site-packages/pandas/core/indexing.pys s(R8RZ(RVRe((ReR›s3lib/python2.7/site-packages/pandas/core/indexing.pyR– scCsµt|tƒrItj|ƒ}t|ƒdkrItjddtjƒSn|dk}|jƒr€|jƒ}||c|7>> validate_indices([1, 2], 3) # OK >>> validate_indices([1, -2], 3) ValueError >>> validate_indices([1, 2, 3], 3) IndexError >>> validate_indices([-1, -1], 0) # OK >>> validate_indices([0, 1], 0) IndexError iÿÿÿÿs5'indices' contains values less than allowed ({} < {})sindices are out-of-boundsN(RtRlR\R[R2Rq(RMRÒtmin_idxtmsgtmax_idx((s3lib/python2.7/site-packages/pandas/core/indexing.pytvalidate_indices; s      cGsYt}x5|D]-}t|tjtttfƒs t}q q W|rQtj|ŒS|SdS(s2 We likely want to take the cross-product N( RKRAR‰RÁRkRRRftix_(targstixifyR"((s3lib/python2.7/site-packages/pandas/core/indexing.pyR«d s   cCs\t|tƒstSxBt|ƒD]4\}}t|ƒsGt|tƒr t|tƒSq WtS(N(RAR8RfRZR RBR(RcRŒR^R_((s3lib/python2.7/site-packages/pandas/core/indexing.pyRbt s cCs,t|ƒo+t|tƒo*t|ƒtk S(N(R RAR8R7(R=((s3lib/python2.7/site-packages/pandas/core/indexing.pyRs scCst|tƒ ot|ƒ S(N(RARBRs(R=((s3lib/python2.7/site-packages/pandas/core/indexing.pyRè‡ scCs:|jdk p9|jdk p9|jdk o9|jdkS(Ni(R%R,R&R'(R+((s3lib/python2.7/site-packages/pandas/core/indexing.pyRŒ scCs||}t|tƒrQx`|D].}y|jdƒ}Wqtk rI|SXqWn'y|jdƒ}Wntk rwnX|S(Ni(RAR8t droplevelR[(RyR=toriginal_indexR³((s3lib/python2.7/site-packages/pandas/core/indexing.pytmaybe_droplevels‘ s    cCsÇtttjƒttjttgƒ}t||ƒrPt dd…|f}nd„}t |ƒst|t ƒsƒ|gg}q½|g}n.g|D]!}||ƒr®|n|g^q–}t|ƒS(s· Ensurse that a slice doesn't reduce to a Series or Scalar. Any user-paseed `subset` should have this called on it to make sure we're always working with DataFrames. NcSs)t|tƒst|ƒo(t|tƒ S(N(RARBR R8(tpart((s3lib/python2.7/site-packages/pandas/core/indexing.pytpred² s( R8RkR)R*RR‰RÁRRAt IndexSliceR RB(tslice_tkindsRZRY((s3lib/python2.7/site-packages/pandas/core/indexing.pyt_non_reducing_slice¤ s     .cCsZ|dkrVtjg}|r.|jtƒntdd…|jd|ƒjf}n|S(s† want nice defaults for background_gradient that don't break with non-numeric data. But if slice_ is passed go with that. Ntinclude(R,R‰tnumberRhRER[t select_dtypesR¡(RÔR\t include_booltdtypes((s3lib/python2.7/site-packages/pandas/core/indexing.pyt_maybe_numeric_sliceÄ s   ((HRRtnumpyR‰tpandas._libs.indexingRt pandas.compatR)RRt pandas.errorsRtpandas.util._decoratorsRtpandas.core.dtypes.commonRRRRR R R R R tpandas.core.dtypes.genericRRRtpandas.core.dtypes.missingRRtpandas.core.commontcoretcommonR3tpandas.core.indexRRRRBR,RéRŸR R[R:R'R(RRRRR8RRR£RDRüRIR•R–RNRRR«RbRsRèRRXR^RfRd(((s3lib/python2.7/site-packages/pandas/core/indexing.pyts`   @ - ÿÿÿÿÿa;ÿxÿS$G<    ,  , )