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

迈不过友情╰ 2022-02-20 13:13 155阅读 0赞

**一、 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][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][https_www.jianshu.com_p_a050fecd5a29]
4.  **np.mean()**  
    np数组取平均值  
    详见：[https://blog.csdn.net/lilong117194/article/details/78397329][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]

1.  **np.eye()和np.identity()**  
    第一个生成对角阵，第二个生成方对角阵  
    详见：[https://blog.csdn.net/m0\_37393514/article/details/81455915][https_blog.csdn.net_m0_37393514_article_details_81455915]
2.  **np.zero()和np.zeros()**
3.  **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]
4.  **np.sum()**
5.  **np.max()**
6.  **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
    	<zip object at 0x103abc288>
    	>>> 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][https_www.jb51.net_article_135377.htm]

[https_blog.csdn.net_lthirdonel_article_details_88690923]: https://blog.csdn.net/lthirdonel/article/details/88690923
[https_www.jianshu.com_p_a050fecd5a29]: https://www.jianshu.com/p/a050fecd5a29
[https_blog.csdn.net_lilong117194_article_details_78397329]: https://blog.csdn.net/lilong117194/article/details/78397329
[https_blog.csdn.net_m0_37393514_article_details_81455915]: https://blog.csdn.net/m0_37393514/article/details/81455915
[https_www.jb51.net_article_135377.htm]: https://www.jb51.net/article/135377.htm