#!/usr/bin/env python
# coding: utf-8

# In[249]:


#全部行都能输出
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"


# In[250]:


import numpy as np


# # 排序函数

# ## np.sort(a, 要排序的轴)  
# a是一个ndarray对象，可以是多维的数组， 但是高维的排序非常复杂， 我们这里只讲二维数组。  
# 按照指定的轴进行升序。

# In[251]:


a = np.array([[4, 2, 8],[1, 5, 6], [9, 3, 7], [1, 5, 2]])
a


# In[252]:


np.sort(a)    # 不指定的时候， 对行进行升序


# In[253]:


np.sort(a, axis=0)   # axis=0代表对列进行升序


# In[254]:


np.sort(a, 1)  # axis=0对列进行升序


# ## np.argsort(a, 排序的轴)  
# 返回的是数组值从小到大的索引值

# In[255]:


a = np.array([[4, 2, 8],[1, 5, 6], [9, 3, 7], [1, 5, 2]])
a


# In[256]:


np.argsort(a)  # 默认对行进行升序


# ```python
# array([[4, 2, 8],    ==> 从小到大排序  2 4 8   ，对应的索引   1 0 2
#        [1, 5, 6],  ==> 从小到大排序  1 5 6   ，对应的索引   0 1 2
#        [9, 3, 7],  ==> 从小到大排序  3 7 9   ，对应的索引   1 2 0
#        [1, 5, 2]])  ==> 从小到大排序  1 2 5   ，对应的索引   0 2 1
# ```

# In[257]:


np.argsort(a, 0)  #axis=0队列进行升序


# ```python
# array([[4, 2, 8],
#        [1, 5, 6],
#        [9, 3, 7],
#        [1, 5, 2]])
#      第一列 4 1 9 1 ==> 从小到大排序 1 1 4 9   ，对应的索引 1 3 0 2
#      第二列 2 5 3 5 ==> 从小到大排序 2 3 5 5   ，对应的索引 0 2 1 3
#      第三列 3 1 2 0 ==> 从小到大排序 0 1 2 3   ，对应的索引 3 1 2 0
# ```

# ## np.lexsort((a, b)

# In[258]:


a = [1,5,1,4,3,4,4] # First column   # 升序是 1 1 3 4 4 4 5 
b = [9,4,0,4,0,2,1] # Second column
a1  = np.array(a)
b1  = np.array(b)
a1
b1


# In[259]:


ind = np.lexsort((b1, a1)) # Sort by a, then by b
ind


# 解释：
# ```python
# 1 首先对a进行从小到大的排序 1 1 3 4 4 4 5 ==》对应的索引 0 2 4 3 5 6 1
# 2 但是， 我们发现有2个1 ， 3个4， 如果是argsort()的话会按原本的位置进行排序， 但是lexsort()不会
# 3 lex()会利用b对应位置上的元素来进行排序
# 4 再来利用b来排序2个1， 两个1的索引是 0 2， 在b中对应的元素为 9 0，从小到大0 9 ， 则索引会变成 2 0 4 3 5 6 1
# 5 再来利用b来排序3个4， 两个1的索引是 3 5 6， 在b中对应的元素为 4 2 1，从小到大1 2 4， 则索引会变成 2 0 4 6 5 3 1
# ```

# ## np.argmax(a,  指定的轴）  
# 返回指定轴上最大元素的索引
# 

# In[260]:


a = np.array([[30,40,70, 4],[80,20,10, 5],[50,90,60, 2]])
a


# In[261]:


np.argmax(a)     # 返回最大元素的所在的整体位置，相当于进行压缩成一维以后的位置


# In[262]:


a.flatten()     # 压缩成一维以后最大元素90的索引为7


# In[263]:


a.flatten()[9]


# In[264]:


np.argmax(a, axis = 0) #按列来求
np.argmax(a, axis = 1) #按行来求


# ## np.argmin(a, 指定的轴)  
# 返回指定的轴上最小的索引

# In[265]:


a = np.array([[30,40,70, 4],[80,20,10, 5],[50,90,60, 2]])
a


# In[266]:


np.argmin(a)     # 返回最大元素的所在的整体位置，相当于进行压缩成一维以后的位置


# In[267]:


a.flatten()


# In[268]:


a.flatten()[11]


# In[269]:


np.argmin(a, axis = 0) #按列来求
np.argmin(a, axis = 1) #按行来求


# ## np.nonzero(a)  
# 返回数组中非0元素的索引

# In[270]:


a = np.array([[30,40,0,0],[0,20,0,10],[50,0,60, 0]])
a


# In[271]:


np.nonzero(a) # #两个是分别按照axis=0,axis=1返回的索引 第一个数组是行，第二个数组是列！


# In[272]:


a[[0, 0, 1, 1, 2, 2], [0, 1, 1, 3, 0, 2]]


# In[273]:


a[np.nonzero(a)]  # 可以通过这种方法找到所有的非0元素


# ## np.where(条件)  
#  返回输入数组中满足给定条件的元素的索引

# In[274]:


x = np.arange(9.).reshape(3, 3)
x


# In[245]:


np.where(x>3)


# In[246]:


x[np.where(x>3)]


# ## np.unique(a)  
# 对数组元素进行去重

# In[247]:


a = np.array([[1, 2, 3, 41, 2, 2, 1, 2], [1, 234, 3, 41, 2, 2, 1, 2], [1, 2, 3, 41, 2, 2, 1, 2]])
a


# In[248]:


np.unique(a)  # 相当于先压缩成一维在进行去重


# In[ ]: