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]

 

转载于:https://www.cnblogs.com/larry-xia/p/9215520.html