论文实现：SR-GNN、DER 中用到的函数

一、 Numpy函数

1. np.arange()：生成np数组

   x = np.arange(9.0) #生成0-8的np数组

2. np.split() ：np数组分割
   详见：https://blog.csdn.net/lthirdonel/article/details/88690923

3. np.asarray() 与 np.array()

   array和asarray都可将结构数据转换为ndarray类型。
   但是主要区别就是当数据源是ndarray时，
   array仍会copy出一个副本，占用新的内存，但asarray不会。
   详见：https://www.jianshu.com/p/a050fecd5a29

4. np.mean()
   np数组取平均值
   详见：https://blog.csdn.net/lilong117194/article/details/78397329

5. np.where()

   numpy.where() 函数返回输入数组中满足给定条件的元素的索引。
   注意：如果是二维数组，索引分成两个数组，一个是一维下标，一个是二维。
   实例 ：

       import numpy as np
       x = np.arange(9.).reshape(3, 3)
       print ('我们的数组是：')
       print (x)
       print ( '大于 3 的元素的索引：')
       y = np.where(x > 3)
       print (y)
       print ('使用这些索引来获取满足条件的元素：')
       print (x[y])
       
   

   输出的数组：

   	我们的数组是：
   	[[0. 1. 2.]
   	 [3. 4. 5.]
   	 [6. 7. 8.]]
   	大于 3 的元素的索引：
   	(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2])) 
   	 使用这些索引来获取满足条件的元素：
   	 [4. 5. 6. 7. 8.]
   

6. np.add()，np.subtract()，np.multiply() 和 np.divide()
   NumPy 算术函数

   实例

    import numpy as np
    a = np.arange(9, dtype = np.float_).reshape(3,3)
    print ('第一个数组：')
    print (a)
    print ('\n')
    print ('第二个数组：')
    b = np.array([10,10,10])
    print (b)
    print ('\n')
    print ('两个数组相加：')
    print (np.add(a,b))
    print ('\n')
    print ('两个数组相减：')
    print (np.subtract(a,b))
    print ('\n')
    print ('两个数组相乘：')
    print (np.multiply(a,b))
    print ('\n')
    print ('两个数组相除：')
    print (np.divide(a,b))
   

   输出结果为：

    第一个数组：
    [[0. 1. 2.]
     [3. 4. 5.]
     [6. 7. 8.]]
    第二个数组：
    [10 10 10]
    两个数组相加：
    [[10. 11. 12.]
     [13. 14. 15.]
     [16. 17. 18.]]
    两个数组相减：
    [[-10.  -9.  -8.]
     [ -7.  -6.  -5.]
     [ -4.  -3.  -2.]]
    两个数组相乘：
    [[ 0. 10. 20.]
     [30. 40. 50.]
     [60. 70. 80.]]
    两个数组相除：
    [[0.  0.1 0.2]
     [0.3 0.4 0.5]
     [0.6 0.7 0.8]]
   

• np.random.shuffle()

  用于打乱数据集

      from numpy as np
      index=np.arange(2000)
      np.random.shuffle(index)
      print(index[0:20])
      X_train=X_train[index,:,:,:]#X_train是训练集，y_train是训练标签
      y_train=y_train[index]
  

7. np.eye()和np.identity()
   第一个生成对角阵，第二个生成方对角阵
   详见：https://blog.csdn.net/m0_37393514/article/details/81455915

8. np.zero()和np.zeros()

9. np.unique()
   numpy.unique 函数用于去除数组中的重复元素。
   numpy.unique(arr, return_index, return_inverse, return_counts)

   • arr：输入数组，如果不是一维数组则会展开
   • return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
   • return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
   • return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数
     实例：

   	import numpy as np
   	a = np.array([5,2,6,2,7,5,6,8,2,9])
   	print ('第一个数组：')
   	print (a)
   	print ('\n')
   	print ('第一个数组的去重值：')
   	u = np.unique(a)
   	print (u)
   	print ('\n')
   	print ('去重数组的索引数组：')
   	u,indices = np.unique(a, return_index = True)
   	print (indices)
   	print ('\n')
   	print ('我们可以看到每个和原数组下标对应的数值：')
   	print (a)
   	print ('\n')
   	print ('去重数组的下标：')
   	u,indices = np.unique(a,return_inverse = True)
   	print (u)
   	print ('\n')
   	print ('下标为：')
   	print (indices)
   	print ('\n')
   	print ('使用下标重构原数组：')
   	print (u[indices])
   	print ('\n')
   	print ('返回去重元素的重复数量：')
   	u,indices = np.unique(a,return_counts = True)
   	print (u)
   	print (indices)
   

   输出结果为：

        第一个数组：
        [5 2 6 2 7 5 6 8 2 9]  
        第一个数组的去重值：
        [2 5 6 7 8 9] 
        去重数组的索引数组：
        [1 0 2 4 7 9] 
        我们可以看到每个和原数组下标对应的数值：
        [5 2 6 2 7 5 6 8 2 9]
        去重数组的下标：
        [2 5 6 7 8 9]   
        下标为：
        [1 0 2 0 3 1 2 4 0 5]    
        使用下标重构原数组：
        [5 2 6 2 7 5 6 8 2 9]
        返回去重元素的重复数量：
        [2 5 6 7 8 9]
        [3 2 2 1 1 1]
   

10. np.sum()

11. np.max()

12. np.around()

二、 Python函数

1. zip()
   zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

	>>>a = [1,2,3]
	>>> b = [4,5,6]
	>>> c = [4,5,6,7,8]
	>>> zipped = zip(a,b) # 返回一个对象
	>>> zipped
	
	>>> list(zipped) # list() 转换为列表
	[(1, 4), (2, 5), (3, 6)]
	>>> list(zip(a,c)) # 元素个数与最短的列表一致
	[(1, 4), (2, 5), (3, 6)]
	>>> a1, a2 = zip(*zip(a,b)) # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
	>>> list(a1)
	[1, 2, 3]
	>>> list(a2)
	[4, 5, 6]

https://www.jb51.net/article/135377.htm