python常用函数和使用技巧日常总结(不定期更新)

版权声明:本文为博主原创文章,转载请说明出处 https://blog.csdn.net/qq_31192383/article/details/79021631

感觉专门花费大量时间去精通一门语言是很困难的,因为许多高深的用法即使你当时学会了,也会因为很少使用导致你很快忘记。反倒是在平时的学习过程中遇到一些很棒的用法记录下来,以便以后使用倒很有帮助。所以打算专门用一篇博文记录我所遇到的python语言中如numpy、matplotlib等比较棒的库的函数用法和技巧。

  • numpy.flatnonzero()
    函数用法大概是这样的:
    输入一个矩阵,返回了其中非零元素的位置:

    >>> import numpy as np
    >>> a = np.array([1,5,0,0,1,2])
    >>> print np.flatnonzero(a)
    [0 1 4 5]

    这个函数比较简单,你以为它只能返回非元素的位置?那你就错了,比如上面的例子,返回1和2的位置:

    >>> print np.flatnonzero(a==1)
    [0 4]
    >>> print np.flatnonzero(a==2)
    [5]

    对于一个n维矩阵,这个函数返回的是将该矩阵按行拉成一列后,每个元素所在的位置的下标。

  • numpy.concatenate((a1, a2, …), axis=0, out=None)
    将矩阵a1,a2….按照某一维度进行拼接:

    >>> a = np.arange(0,12,1)
    >>> a = a.reshape((4,3))
    >>> print a
    [[ 0  1  2]
     [ 3  4  5]
     [ 6  7  8]
     [ 9 10 11]]
    >>> b = np.arange(0,-6,-1)
    >>> b = b.reshape((2,3))
    >>> print b
    [[ 0 -1 -2]
     [-3 -4 -5]]
    >>> c = np.concatenate((a,b),axis=0) #沿着第一个维度进行拼接
    >>> prnint c
    [[ 0  1  2]
     [ 3  4  5]
     [ 6  7  8]
     [ 9 10 11]
     [ 0 -1 -2]
     [-3 -4 -5]]
    
    >>> b = np.arange(0,-8,-1)
    >>> b = b.reshape((4,2))
    >>> print b
    [[ 0 -1]
     [-2 -3]
     [-4 -5]
     [-6 -7]]
    >>> c = np.concatenate((a,b),axis=1)  #沿着第二个维度进行拼接
    >>> print c
    [[ 0  1  2  0 -1]
     [ 3  4  5 -2 -3]
     [ 6  7  8 -4 -5]
     [ 9 10 11 -6 -7]]

    技巧:因为矩阵的拼接需要满足维度匹配的要求,所以在如果我们在高维度矩阵拼接时,遵循下面准则,就能保证不出错:要沿着x维度进行拼接,保证除了该维度以外的其他所有维度的维数一致,拼接后的矩阵除了x维度变化以外,其他维度均保持不变。 举个列子:

    >>> a = np.arange(0,24,1)
    >>> a = a.reshape((4,3,2,1))
    >>> b = np.arange(0,-16,-1)
    >>> b = b.reshape((4,2,2,1))
    >>> c = np.concatenate((a,b),axis=1)   #如果我想沿着第二个维度进行拼接,则矩阵b的第1、3、4维的维数和a的对应维度维数一致
    >>> print c.shape
    (4, 5, 2, 1)       #拼接后的矩阵除了第2维变大,其它维度和a保持一致
  • numpy.random.choice(a, size=None, replace=True, p=None)
    可以从一个int数字或1维array里随机选取内容,并将选取结果放入n维array中返回。p是一个一维度列表,对于于a中每个元素被选中的概率。

    >>> a = np.arange(1,10,1)
    >>> print a
    [1 2 3 4 5 6 7 8 9]
    >>> print (np.random.choice(a,size=9,replace=True))    #replace代表是否有放回的随机选取,True表示有放回
    [8 4 1 3 8 8 3 3 7]
    >>> print (np.random.choice(a,size=9,replace=False))     #False表示无放回
    [2 4 7 8 5 3 1 9 6]
    >>> np.random.choice(a,size=10,replace=True,p=[0,0,0.1,0.1,0.2,0.1,0.3,0.1,0.1]) #指定对应元素被选中的概率,可以看到7的概率最大,所以出现的次数最多
    array([8, 6, 5, 5, 7, 3, 5, 7, 7, 5])
    
  • numpy.array_split(ary, indices_or_sections, axis=0)和numpy.split(ary, indices_or_sections, axis=0)
    这两个函数都可以将一个多为数组按照指定维度进行切分,ary是被切分的对象数组,indices_or_sections是指定被切分的份数或一个列表(见下面示例),axis为指定维度。这两个函数唯一的区别是,split只能划分为等分的子数组,而array_split可以划分为长度不等的子数组,其计算公式如下,l为数组被切分维度的长度,n为被切分份数,则它返l%n个长度为(l//n)+1的子数组,其余的(n-l%n)个子数组长度为l//n(//为取整符号):

    
    ##能等分的例子
    
    >>> x = np.arange(12)
    >>> np.split(x, 3)
    [array([0, 1, 2, 3]), array([4, 5, 6, 7]), array([ 8,  9, 10, 11])]
    >>> np.array_split(x, 4)
    [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8]), array([ 9, 10, 11])]
    
    #按给定列表进行指定等分划分,可以把列表中的元素看作是原数组中被切分的位置的下标
    
    >>> np.array_split(x, [2, 5, 9, 11])
    [array([0, 1]), array([2, 3, 4]), array([5, 6, 7, 8]), array([ 9, 10]), array([11])]
    >>> np.split(x, [2, 5, 9, 11])
    [array([0, 1]), array([2, 3, 4]), array([5, 6, 7, 8]), array([ 9, 10]), array([11])]
    
    #不能被等分的例子,可以看到数组长度为12,分成5分,不能保证每一份的元素个数相等,因此split函数会报错,而对于array_split则会通过前面的公式来指定每一个子数组的大小,首先12%5=2,因此前两个数组的大小为(12//5)+1=3,剩下的(5-12%5)= 3个数组大小为12//5=2,所以结果为[array([0, 1, 2]), array([3, 4, 5]), array([6, 7]), array([8, 9]), array([10, 11])]
    
    >>> x = np.arange(12)
    >>> np.split(x, 5)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "/home/forever/anaconda2/lib/python2.7/site-packages/numpy/lib/shape_base.py", line 541, in split
        'array split does not result in an equal division')
    ValueError: array split does not result in an equal division
    >>> np.array_split(x, 5)
    [array([0, 1, 2]), array([3, 4, 5]), array([6, 7]), array([8, 9]), array([10, 11])]
  • python中list和numpy数组,对于赋值操作(=)都是属于浅拷贝,即指向同一块内存地址

    >>> a = np.arange(10)
    >>> a
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> b = a
    >>> a[0] -= 10
    >>> a
    array([-10,   1,   2,   3,   4,   5,   6,   7,   8,   9])
    >>> b
    array([-10,   1,   2,   3,   4,   5,   6,   7,   8,   9])   #b也会被修改
    >>> a = list(np.arange(10))
    >>> a
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> b = a
    >>> a[0] -= 10
    >>> a
    [-10, 1, 2, 3, 4, 5, 6, 7, 8, 9]      #b也会改变
    >>> b
    [-10, 1, 2, 3, 4, 5, 6, 7, 8, 9]    
  • numpy.stack和numpy.hstack、numpy.vstack

  • python中numpy矩阵元素的访问
    这是我们经常用的操作,但是其实很多时候我们对其中的原理并不是特别清楚,比如:

    >>> a = np.arange(0,28)
    >>> a = a.reshape([4,7])
    >>> a
    array([[ 0,  1,  2,  3,  4,  5,  6],
           [ 7,  8,  9, 10, 11, 12, 13],
           [14, 15, 16, 17, 18, 19, 20],
           [21, 22, 23, 24, 25, 26, 27]])
    >>> a[1,2]
    9
    >>> a[1][2]
    9

    这两种方式都可以完成一样的操作,即访问数组中的元素,但是其实它们是不一样的,看下面的例子:

    >>> a[0:3, 1:3]
    array([[ 1,  2],
           [ 8,  9],
           [15, 16]])
    >>> a[0:3][1:3]
    array([[ 7,  8,  9, 10, 11, 12, 13],
           [14, 15, 16, 17, 18, 19, 20]])

    可以看到,在这种情况下,前者其实是切片草组,也就是从原数组中不破坏其结构的从中抽取部分行与列(对于二维数组来说),而后者则是先返回a[0:3]即原数组的前三行,然后再从这三行形成的新数组中返回[1:3]行,因此返回的数组列的维度不变。

  • numpy.maximum(X, Y, out=None)
    将X和Y进行比较,并取最大者

>>> a
array([1, 2, 3, 4, 5, 6])
>>> b
array([2, 4, 5, 2, 1, 4])
>>> np.maximum(a,b)
array([2, 4, 5, 4, 5, 6])
>>> a = np.arange(0,28)
>>> a = a.reshape([4,7])
>>> a
array([[ 0,  1,  2,  3,  4,  5,  6],
       [ 7,  8,  9, 10, 11, 12, 13],
       [14, 15, 16, 17, 18, 19, 20],
       [21, 22, 23, 24, 25, 26, 27]])
>>> np.maximum(a,10)     #用到了python的广播机制
array([[10, 10, 10, 10, 10, 10, 10],
       [10, 10, 10, 10, 11, 12, 13],
       [14, 15, 16, 17, 18, 19, 20],
       [21, 22, 23, 24, 25, 26, 27]])
  • numpy.zeros_like(a, dtype=None, order=’K’, subok=True)
    创建一个与给定数组维度一样的元素全是0的新数组,后面两个参数一般不使用。(order:可选参数,c代表与c语言类似,行优先;F代表列优先)

    >>> x = np.arange(6)
    >>> x = x.reshape((2, 3))
    >>> x
    array([[0, 1, 2],
           [3, 4, 5]])
    >>> np.zeros_like(x)
    array([[0, 0, 0],
           [0, 0, 0]])
    >>> y = np.arange(3, dtype=float)
    >>> y
    array([ 0.,  1.,  2.])
    >>> np.zeros_like(y)
    array([ 0.,  0.,  0.])
  • numpy.prod(a, axis=None, dtype=None, out=None, keepdims=bool)
    对一个多维数组,返回指定维度上元素的乘积,示例:

    >>> a = np.arange(1, 29) / 100.
    >>> a
    array([ 0.01,  0.02,  0.03,  0.04,  0.05,  0.06,  0.07,  0.08,  0.09,
            0.1 ,  0.11,  0.12,  0.13,  0.14,  0.15,  0.16,  0.17,  0.18,
            0.19,  0.2 ,  0.21,  0.22,  0.23,  0.24,  0.25,  0.26,  0.27,  0.28])
    >>> a = a.reshape((4,7))
    >>> np.prod(a, axis = 0)
    array([  2.64000000e-05,   6.62400000e-05,   1.22400000e-04,
             1.98000000e-04,   2.96400000e-04,   4.21200000e-04,
             5.76240000e-04])
    >>> np.prod(a, axis = 1)
    array([  5.04000000e-11,   1.72972800e-07,   5.86051200e-06,
             5.96756160e-05])
    >>> np.prod(a, axis = (0, 1))
    3.0488834461171415e-27
    >>> np.prod(a)
    3.0488834461171415e-27
    
阅读更多
换一批

没有更多推荐了,返回首页