ENH:New API of indexing
#### Is your feature request related to a problem?

the old indexing API some time is lack of function
so I design this indexing API with more functions and easy rules

#### loc mg cc and supporting equipment
```python
1)  #directly indexing, will treat the index as ".iloc" index
    eg. df[1,2] <==> df.iloc[1,2] # old indexing
2)  #if we want some "loc" index, we use loc[] wrap it
    eg. df[loc[a],:]         <==> df[df.index.get_loc(a),:]
    eg. df[loc[a]:b:c,:]     <==> df[df.index.get_silce_bound(a,'left','loc'):b:c,:]
    eg. df[loc[[a,b,c,d]],:] <==> df[df.index.get_indexer_for([a,b,c,d]),:]
3)  #loc expand rule : the df.loc[r,c] is complitetly equalivent to df[loc[r],loc[c]]
    eg. df.loc[     a,:] <==> df[                loc[a],loc[:]]
    eg. df[loc[a:b:c],:] <==> df[  loc[a]:loc[b]:loc[c],    : ]
    eg. df[loc[a,b,c],:] <==> df[[loc[a],loc[b],loc[c]],    : ]
4)  #for slice, the slice.step choose how to slice
4.1)  #if slice.step is wraped by loc
        #the index dtype should be "strongly ordered"
        #I get element which label meet conditions
        eg. df[loc[start]:loc[end]:loc[step]] <==> df[(start <= x) & (x <= end) & ((x-start) % step == 0),:]
        #if start or step is NOT wraped by loc
        #use x[start] or x[stop] instead in condition expretions
        eg. df[start:loc[end]:loc[step]] <==> df[(x[start] <= x) & (x <= end) & ((x-x[start]) % step == 0),:]
4.2)  #if slice.step is NOT wraped by loc
        #I get element like old slice
        eg. df[start:end:step,:] <==> df.iloc[start:end:step,:] # old indexing
        if start or step is wraped by loc
        use index.get_slice_bound to get postions
        eg. df[start:loc[end]:step,:] <==> df[start:index.get_slice_bound(end,'right','loc'):step,:]
4.3)  #if step < 0
        #swap start and stop, and set step to its opposite
        #and reverse the result
        eg. df[loc[start]:loc[end]:loc[-1]] <==> df[rev(loc[end]:loc[start]:loc[1]),:] # rev just for this pseudocode
4.4)    by passing arg 'closed' to loc # default is 'both'
        can decide the interval of slice
        eg. 
            lloc = loc(closed='left')
            rloc = loc(closed='right')
            nloc = loc(closed='neither')
            I    = index
            gsb  = index.get_slice_bound
            df[ loc[2]: loc[10]:,:] <==> df[gsb(start, 'left','loc'):gsb(end,'right','loc'):],:]
            df[lloc[2]:lloc[10]:,:] <==> df[gsb(start, 'left','loc'):gsb(end, 'left','loc'):],:]
            df[rloc[2]:rloc[10]:,:] <==> df[gsb(start,'right','loc'):gsb(end,'right','loc'):],:]
            df[nloc[2]:nloc[10]:,:] <==> df[gsb(start,'right','loc'):gsb(end, 'left','loc'):],:]
            df[ loc[2]: loc[10]: loc[None],:] <==> df[ loc[2:10:],:] <==> df[(2<=I)&(I<=10),:]
            df[lloc[2]:lloc[10]:lloc[None],:] <==> df[lloc[2:10:],:] <==> df[(2<=I)&(I< 10),:]
            df[rloc[2]:rloc[10]:rloc[None],:] <==> df[rloc[2:10:],:] <==> df[(2< I)&(I<=10),:]
            df[nloc[2]:nloc[10]:nloc[None],:] <==> df[nloc[2:10:],:] <==> df[(2< I)&(I< 10),:]
        # if loc is different
        # will use the 'closed' arg of step's loc and raise warning
5)  #for multi index
    #use the default directly tuple indexing
    eg. df[[[1,0],[1,1],[2,0]],:]    <==> df[df.index.isin([1,0],[1,1],[2,0]),:]
    eg. df[loc[[1,0],[1,1],[2,0]],:] <==> df[df.index.get_locs([1,0],[1,1],[2,0]),:]
    using cc to index from index like pandas.MultiIndex.fromArray() make
    # Aka cc:concat
    eg. df[cc[[1,2,3],[1,2,3]], :]     <==> df[[[1,1],[2,2],[3,3]], :]
    eg. df[cc.loc[[1,2,3],[1,2,3]], :] <==> df[loc[[1,1],[2,2],[3,3]], :]
    using mg to index from index like pandas.MultiIndex.fromProduct make
    # Aka mg:meshgrid
    eg. df[mg[[1,2],[1,2]], :]     <==> df[[[1,1],[1,2],[2,1],[2,2]], :]
    eg. df[mg.loc[[1,2],[1,2]], :] <==> df[loc[[1,1],[1,2],[2,1],[2,2]], :]
    #if you want to index with level
    #can pass less indexer than multiindex have
    #or use : to take up postions
    eg. df[mg[[1,2]], :]    <==> df[[index.get_loc_level([1,2],0)]]
    eg. df[mg[:,[1,2]], :]  <==> df[[index.get_loc_level([1,2],1)]]
    #you can pass level directly to 'cc' or 'mg'
    eg. df[mg({0})[[1,2]], :]
    #you can also use slice on levels
    eg. TODO
    #if you use through cc
    cc will check the result of level indexing by slice is equal
    and raise error 
```
#### API breaking implications

pd.DataFrame used index as columns
df[['A','B']] seems will be broken
