CLN: implement xs in terms of loc

[jreback]

after #6134 we can drop xs and implement directly. Thus we should deprecate it.

.xs(key, level=n)

is roughly equivalent to this

indexer = tuple([slice(None)]*(n-1) + key)]
axis_indexer = [ slice(None) ] * self.ndim
axis_indexer[axis] = indexer
self.loc[tuple(axis_indexer)]

roughly because needs to handle .xs full argument set

• drop_level (need to surround the indexer tuple with a list or not)
• n could be a level name
• n = 1 (needs a test)

[cpcloud]

I don't think we should deprecate it. Why not just implement xs with the above?

[jreback]

definitly should reimplement with above...

deprecate because then the selection becomes less confusing, e.g. want to get a value by location, then use .loc, don't have to think/worry if its a cross-section or not

see #5421

[cpcloud]

Yeah, I just abhor having to type four lines instead of a call to xs. Don't think loc et al can be overloaded any more before reaching critical mass

[jreback]

no....that's the implementation....after #6134

you just do:

df.loc[key] for df.xs(key,level=0)
df.loc[(slice(None),key)] for df.xs(key,level=1)
df.loc[(slice(None),slice(None),key)] for df.xs(key,level=2)

etc I suppose it has its uses instead of typing empty levels..(but that's about it)

[cpcloud]

How will you disambiguate selecting a column by name with loc vs this kind of selection? Python makes no distinction between colon and none slices except at the syntactic level so your above example is equivalent to df.loc[:, key] which already does column selection. There's no way to tell apart what you've written above from that example. Am I missing something?

[jreback]

hmm...this is a very good point..#6134 won't work as advertised then...

easy way to 'fix' this is to allow a tuple/list for the key in xs, but then the assigning is problematic

how do we feel about

df.loc(level=1)[key]

or to disambiguate

df.loc(axis=0)[slice(None)

hmm....

[jreback]

@y-p want to weigh in here, I didn't think about this with #6134, how to disambiguate?

e.g.

In [1]: mi = pd.MultiIndex.from_product([['A0', 'A1', 'A2'],['B0', 'B1']])

In [2]: mi.get_values()
Out[2]: 
array([('A0', 'B0'), ('A0', 'B1'), ('A1', 'B0'), ('A1', 'B1'),
       ('A2', 'B0'), ('A2', 'B1')], dtype=object)

In [3]: df = DataFrame(np.random.randn(6,2),index=mi,columns=list('AB'))

In [4]: df
Out[4]: 
              A         B
A0 B0 -0.195160  0.397622
   B1 -0.081161 -1.433219
A1 B0  0.443265  0.414330
   B1 -2.500851  0.458434
A2 B0 -1.358423  0.559703
   B1  0.365160  0.846487

raises (even though we'd like it to work)

In [7]: df.loc[(slice(None),'B1')]

One tuple per axis.

df.loc[(slice(None),'B1'),:]

as advertised in the #6134 example.

[jreback]

doesn't work, its mis-interpreted because you cannot disambiguate

Disambiguate with what? give me an example of something that's indistinguishable
from df.loc[(slice(None),'B1'),:] but already means something different.

[cpcloud]

df.loc[(slice(None), 'B1'), :] -> df.loc[:'B1', :]which as you know is rows up to and including 'B1' from the row index.

That's so broken. But, It also doesn't seem to be true:

In [13]: class A(object):
    ...:     def __getitem__(self,*args):
    ...:         return args
    ...: df=A()
    ...: print df[(slice(None), 'B1'), :]
    ...: print df[:'B1', :]
(((slice(None, None, None), 'B1'), slice(None, None, None)),)
((slice(None, 'B1', None), slice(None, None, None)),)

am I missing something?

[jreback]

with #6134

In [4]: df.loc[(slice(None),'B1'),:]
Out[4]: 
Empty DataFrame
Columns: [A, B]
Index: []

[0 rows x 2 columns]

[cpcloud]

The difference is that you're passing in a tuple of tuples, so I was wrong about the equivalence.