• NumPy数值计算库-1


    from numpy import *
    print(random.rand(4,4))   #4*4随机数组
    randMat=mat(random.rand(4,4))  #mat()将数组转化为矩阵
    print(randMat)

    Numpy提供了两种基本的对象:

    • ndarray   (n-dimensional array object)数组
    • ufunc       (universal function object)是一种对数组进行处理的特殊函数

    ndarray

     1 import numpy as np
     2 a=np.array([1,2,3,4])
     3 b=np.array((5,6,7,8))
     4 c=np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]])
     5 print(a.shape)  #获取数组的形状,返回一个元组  (4,)
     6 print(c.shape)  # (3,4)
     7 c.shape=4,3  #通过shape属性可修改数组每个维度的长度
     8 print(c)
     9 c.shape=2,-1  #设置某个维度长度为-1,自动计算此维度的长度
    10 print(c)
    c=np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]])
    print(c.dtype)  #获取数组元素类型  -->int32
    af=np.array([1,2,3,4],dtype=float)  #通过dtype在创建数组时指定元素类型
    print(af.dtype)  #  -->float64

    numpy中typeDict字典保存所有数值类型

    使用astype()方法对数组元素进行类型转换:

    1 t1=np.array([1,2,3,4],dtype=np.float)
    2 t2=t1.astype(np.int32)
    3 print(t1.dtype) #-->float64
    4 print(t2.dtype) #-->int32

    自动创建数组

    1 t1=np.arange(0,1,0.1) #使用arange()创建等差数组
    2 print(t1)  # --> [ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9]
    3 t2=np.linspace(0,1,10) #指定开始值0,终值1和元素个数10创建等差数组
    4 t3=np.linspace(0,1,10,endpoint=False)  #endpoint参数指定是否包含终值
    t1=np.logspace(0,2,5) #创建等比数组,产品从10^0到10^2共5个元素
    print(t1) # -->[   1.            3.16227766   10.           31.6227766   100.        ]
    t=np.logspace(0,1,12,base=2,endpoint=False) #指定基数为2,不包含终值
    print(t)
    #[ 1.          1.05946309  1.12246205  1.18920712  1.25992105  1.33483985
    #  1.41421356  1.49830708  1.58740105  1.68179283  1.78179744  1.88774863]

    zeros(),ones(),empty()创建指定形状和类型的数组,其中empty()只分配数组所使用的内存,不对数组元素进行初始化操作。

    1 t1=np.zeros(4,np.int)
    2 print(t1)  #--> [0 0 0 0]
    3 t2=np.full(4,np.pi)  #full()将数组元素初始化为指定的值
    4 print(t2)  #--> [ 3.14159265  3.14159265  3.14159265  3.14159265]
    5 s='abcdefgh'
    6 t3=np.fromstring(s,dtype=np.int8)  #从字符串创建数组
    7 print(t3)  #-->[ 97  98  99 100 101 102 103 104]

    可通过fromfunction()创建数组,第一个参数为计算每个数组元素的函数,第二个参数指定数组的形状

    def func2(i,j):
        return (i+1)*(j+1)
    
    t1=np.fromfunction(func2,(9,9))
    print(t1)
    # [[  1.   2.   3.   4.   5.   6.   7.   8.   9.]
    #  [  2.   4.   6.   8.  10.  12.  14.  16.  18.]
    #  [  3.   6.   9.  12.  15.  18.  21.  24.  27.]
    #  [  4.   8.  12.  16.  20.  24.  28.  32.  36.]
    #  [  5.  10.  15.  20.  25.  30.  35.  40.  45.]
    #  [  6.  12.  18.  24.  30.  36.  42.  48.  54.]
    #  [  7.  14.  21.  28.  35.  42.  49.  56.  63.]
    #  [  8.  16.  24.  32.  40.  48.  56.  64.  72.]
    #  [  9.  18.  27.  36.  45.  54.  63.  72.  81.]]
    a=np.arange(10)
    print(a) #[0 1 2 3 4 5 6 7 8 9]
    print(a[2:-1:2])  #用切片获取数组一部分,step=2  -->[2 4 6 8]

    与列表不同的是,通过切片获取的新的数组时原始数组的一个视图,它与原始数组共享同一块存储空间。

    a=np.arange(10)
    print(a) #[0 1 2 3 4 5 6 7 8 9]
    b=a[3:7]
    print(b)  #-->[3 4 5 6]
    b[2]=-10
    print(b)  #--> [  3   4 -10   6]
    print(a) #-->[  0   1   2   3   4 -10   6   7   8   9]

    使用整数列表对数组元素进行存取,将使用列表中的每个元素作为下标,得到的数组和原始数组不共享内存

    x=np.arange(10,1,-1)
    print(x) #-->[10  9  8  7  6  5  4  3  2]
    b=x[[3,3,-2,8]]
    print(b)  #-->[7 7 3 2]
    b[2]=100
    print(b)  #-->[  7   7 100   2]
    print(x)  #-->[[10  9  8  7  6  5  4  3  2]

    NumPy使用元组作为下标

     二维数组

    a=np.arange(0,60,10).reshape(-1,1)+np.arange(0,6)
    print(a)
    # [[ 0  1  2  3  4  5]
    #  [10 11 12 13 14 15]
    #  [20 21 22 23 24 25]
    #  [30 31 32 33 34 35]
    #  [40 41 42 43 44 45]
    #  [50 51 52 53 54 55]]

    在多维数组中,可以使用整数元组或者列表。整数数组和布尔数组,当下标使用这些对象时,所获得的数据是原始数据的副本,因此修改数组不会改变原始数组。

    数组内存结构

     ufunc函数

    ufunc是一种能对数组的每一元素进行计算的函数,NumPy的许多ufunc函数都是用C语言实现的,因此它的计算速度非常快。

    逻辑运算函数logical_and(),logical_or(),logical_not(),logical_xor()

    位运算函数bitwise_and(),bitwise_not(),bitwise_or(),bitwise_xor()

    自定义ufunc函数:

    def triangle_wave(x,c,c0,hc):
        x=x-int(x) #三角波周期为1
        if x>=c:
            r=0.0
        elif x<c0:
            r=x/c0*hc
        else:
            r=(c-x)/(c-c0)*hc
        return r
    
    #通过frompyfunc()将计算单个值的函数转换为能对数组每个元素进行计算的ufunc函数
    triangle_ufunc1=np.frompyfunc(triangle_wave,4,1)
    x=np.linspace(0,2,10)
    y2=triangle_ufunc1(x,0.6,0.4,1.0)
    print(y2.dtype)  #triangle_ufunc1()返回的数组元素类型为object
    print(y2.astype(np.float).dtype) #使用astype()将元素类型转为float

    使用vectorize()也可以实现frompyfunc()类似的功能,可通过otypes参数指定返回的数组的元素类型:

    triangle_ufunc2=np.vectorize(triangle_wave,otypes=[np.float])
    x=np.linspace(0,2,10)
    y2=triangle_ufunc2(x,0.6,0.4,1.0)
    print(y2)

    广播

    当使用ufunc函数对两个数组进行计算时,如果两个数组的shape不同,会进行广播处理。Numpy提供了ogrid对象,用于创建广播运算用的数组。

    ogrid第三个参数为虚数时,它表示所返回的数组的长度。

    x,y=np.ogrid[:1:4j,:1:3j]
  • 相关阅读:
    项目团队技术个人(提拔篇)
    Android开发者掘金(2)—技术篇
    Android开发者掘金(3) 未来
    在Android应用中放置AdMob广告的详细教程
    ant build apk
    手机产品设计中的 15 大禁忌
    Android开发者掘金(1)
    项目团队技术个人(专业篇)
    #pragram预处理指令
    c++ 异常机制
  • 原文地址:https://www.cnblogs.com/larry-xia/p/9215520.html
Copyright © 2020-2023  润新知