import numpy as np

创建ndarray

data1 = [6,7.5, 8, 0, 1]
arr1 = np.array(data1)

print(arr1)

创建多维数组

data2 = [[1,2,3,4],[5,6,7,8]]
arr2 = np.array(data2)
print(arr2)

多维数组的维数

arr2.ndim #2
arr2.shape #(2,4)

数组的数据类型

arr2.dtype # dtype('float64')

创建指定长度和形状的全零和全1数组

np.zeros(10)

np.zeros(3,6)
np.zeros_like(arr2)
np.ones(10)
np.ones_like(arr2)

创建一个没有任何具体指的数组

np.empty((2,3,4))
np.empty_like(arr2)

创建等差数组

np.arange(15)

创建一个正方的N X N单位的矩阵(对角线为1，其余为0)

将输入装换为ndarray,

np.asarray(data)

ndarray的数据类型有浮点型，复数，整数，布尔值，字符串和普通的Python对象

arr1 = np.array([1,2,3], dtype = np.float64)
arr2 = np.array([1,2,3], dtype = np.int32)

转换数据类型

arr = np.array([1,2,3,4,5])
float_arr = arr.astype(np.float64)

numertic_strings = np.array(['-1.2', '-4.5', '8'], dtype = np.string_)
numertic_strings.astype(np.float64)

转换数据类型的另一种用法

int_array = np.array(10)
calibers = np.array([.22, .27, .357, .380, .44, .5], dtype = np.float64)
int_array.astype(calibers.dtype)

数组与标量之间的运算

arr = np.array([[1.,2.,3.], [4., 5., 6.]])

arr * arr

arr - arr

1 / arr

arr ** 0.5

基本的索引和切片

arr = np.arange(10)

arr[5]

arr[5:8]

arr[5:8] = 12

二维数组的索引

arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

arr2d[2]
arr2d[0][2]
arr2d[0,2]

多维数组的索引如果省略了后面的索引，则返回对象会是一个维度低一点的ndarray

切片索引

arr[1:6]

arr2d[:2]
arr2d[:2,1:]
arr2d[1,:2]
arr2d[2,:1]

布尔型索引

names=np.array(['bob','joe','will','bob', 'will', 'joe', ' joe'])
data = randn(7,4)
names == 'bob'
data[names == 'bob']
data[names == 'bob', 2:]

data[-(names == 'bob')]

data[(name == 'bob') | (name == 'will')]

data[ data < 0 ] = 0

Fancy indexing

arr = np.empyt((8,4))
for i in range(8):
arr[i] = i
arr[[4,3,0,6]]
arr[[-3,-5,-7]]

arr = np.arange(32).reshape((8,4))

arr[[1,5,7,2],[0,3,1,2]]

数组转置和轴对称

arr = np.arange(15).reshape((3,5))

arr.T

arr = np.random.randn(6,3)
np.dot(arr.T,arr)

通用函数：快速的元素级 数组函数

arr = np.arange(10)
np.sqrt(arr)

np.exp(arr)

x = np.random.randn(8)
y = np.random.randn(8)
np.maximum(x,y)

modf() #用于显示浮点数组的小数和整数部分

np.abs()
np.fabs()

np.sqrt()

np.square() # arr**2

np.exp()

np.log() #e

np.log10()

np.log2()

np.log1p() # log(1 + x)

np.sign() # 计算各元素的正负号

np.ceil() # 大于等于该数的最小整数

np.floor() # 小于等于概述的最大整数

np.rint() # 四舍五入 保留dtype

np.modf() #

np.isnan()

np.isfinite()

np.isinf()

np.cos()

np.cosh()

np.sin()

np.sinh()

np.tan()

np.tanh()

还有反三角函数

二元函数

np.add()
np.substract()
np.multiply()
np.divide()
np.floor_divide()
np.power()
np.maximum()
np.fmax()
np.minimum()
np.fmin()
np.mod()
np.copysign()

将条件逻辑表述为数组运算

result = np.where(cond,xarr,yarr)

数学和统计方法

np.sum()
np.mean()

np.std() # 标准差
np.var() # 方差
np.max()
np.min()
np.argmax()
np.argmin() #最大和最小元素的索引

np.cumsum() # 所有元素的累计和
np.cumprod() # 所有元素的累计积

用于布尔型数组的方法

arr = np.random.randn(100)

(arr > 0).sum()
any() # 用于测试数组中是否存在一个或多个true
all() # 用于测试数组中所有值是否都是True

排序

arr = np.random.randn(8)

arr.sort()

唯一化以及其他的集合逻辑

names = np.array(['Bob','Joe', 'Will', 'Joe', 'Joe'])
np.unique(names)# 计算names中的唯一元素，并返回有序结果

np.in1d用于测试一个数组中的值在另一个数组中的成员资格，返回一个布尔型数组

values = np.array([6,0,0,3,2,5,6])
np.in1d(values,[2,3,6])

np.intersect1d(x,y) #计算x和y的公共元素，并返回有序结果

np.union1d(x,y) #计算x和y的并集，并返回有序结果

np.in1d(x,y) #得到一个表示"x的元素是否包含于y"的布尔型数组

np.setdiff1d(x,y) # 集合的差，即元素在x中且不再y中

np.setxor1d(x,y) # 集合的对称差，即存在于一个数组中但不同时存在于两个数组中的元素

用于数组文件的输入输出

np.save()

np.load()

线性代数

np.dot(A,B) #矩阵的乘积

from numpy.linalg import inv, qr

详见p110

随机数的生成

numpy模块中的矩阵对象为numpy.matrix，包括矩阵数据的处理，矩阵的计算，以及基本的统计功能，转置，可逆性等等，包括对复数的处理，均在matrix对象中。 class numpy.matrix(data,dtype,copy):返回一个矩阵，其中data为ndarray对象或者字符形式；dtype:为data的type；copy:为bool类型。

a = np.matrix('1 2 7; 3 4 8; 5 6 9')
a #矩阵的换行必须是用分号(;)隔开，内部数据必须为字符串形式(‘ ’)，矩
matrix([[1, 2, 7], #阵的元素之间必须以空格隔开。
[3, 4, 8],
[5, 6, 9]])

b=np.array([[1,5],[3,2]])
x=np.matrix(b) #矩阵中的data可以为数组对象。
x
matrix([[1, 5],
[3, 2]])

矩阵对象的属性：
matrix.T transpose：返回矩阵的转置矩阵
matrix.H hermitian (conjugate) transpose：返回复数矩阵的共轭元素矩阵
matrix.I inverse：返回矩阵的逆矩阵
matrix.A base array：返回矩阵基于的数组
矩阵对象的方法：
all([axis, out]) :沿给定的轴判断矩阵所有元素是否为真(非0即为真)
any([axis, out]) :沿给定轴的方向判断矩阵元素是否为真，只要一个元素为真则为真。
argmax([axis, out]) :沿给定轴的方向返回最大元素的索引（最大元素的位置）.
argmin([axis, out]): 沿给定轴的方向返回最小元素的索引（最小元素的位置）
argsort([axis, kind, order]) :返回排序后的索引矩阵
astype(dtype[, order, casting, subok, copy]):将该矩阵数据复制，且数据类型为指定的数据类型
byteswap(inplace) Swap the bytes of the array elements
choose(choices[, out, mode]) :根据给定的索引得到一个新的数据矩阵（索引从choices给定）
clip(a_min, a_max[, out]) :返回新的矩阵，比给定元素大的元素为a_max，小的为a_min
compress(condition[, axis, out]) :返回满足条件的矩阵
conj() :返回复数的共轭复数
conjugate() :返回所有复数的共轭复数元素
copy([order]) :复制一个矩阵并赋给另外一个对象，b=a.copy()
cumprod([axis, dtype, out]) :返回沿指定轴的元素累积矩阵
cumsum([axis, dtype, out]) :返回沿指定轴的元素累积和矩阵
diagonal([offset, axis1, axis2]) :返回矩阵中对角线的数据
dot(b[, out]) :两个矩阵的点乘
dump(file) :将矩阵存储为指定文件,可以通过pickle.loads()或者numpy.loads()如:a.dump(‘d:\a.txt’)
dumps() :将矩阵的数据转存为字符串.
fill(value) :将矩阵中的所有元素填充为指定的value
flatten([order]) :将矩阵转化为一个一维的形式，但是还是matrix对象
getA() :返回自己，但是作为ndarray返回
getA1()：返回一个扁平（一维）的数组（ndarray）
getH() :返回自身的共轭复数转置矩阵
getI() :返回本身的逆矩阵
getT() :返回本身的转置矩阵
max([axis, out]) ：返回指定轴的最大值
mean([axis, dtype, out]) :沿给定轴方向，返回其均值
min([axis, out]) ：返回指定轴的最小值
nonzero() :返回非零元素的索引矩阵
prod([axis, dtype, out]) :返回指定轴方型上，矩阵元素的乘积.
ptp([axis, out]) :返回指定轴方向的最大值减去最小值.
put(indices, values[, mode]) :用给定的value替换矩阵本身给定索引（indices）位置的值
ravel([order]) :返回一个数组，该数组是一维数组或平数组
repeat(repeats[, axis]) :重复矩阵中的元素，可以沿指定轴方向重复矩阵元素，repeats为重复次数
reshape(shape[, order]) :改变矩阵的大小,如：reshape([2,3])
resize(new_shape[, refcheck]) :改变该数据的尺寸大小
round([decimals, out]) :返回指定精度后的矩阵，指定的位数采用四舍五入，若为1，则保留一位小数
searchsorted(v[, side, sorter]) :搜索V在矩阵中的索引位置
sort([axis, kind, order]) :对矩阵进行排序或者按轴的方向进行排序
squeeze([axis]) :移除长度为1的轴
std([axis, dtype, out, ddof]) :沿指定轴的方向，返回元素的标准差.
sum([axis, dtype, out]) ：沿指定轴的方向，返回其元素的总和
swapaxes(axis1, axis2):交换两个轴方向上的数据.
take(indices[, axis, out, mode]) :提取指定索引位置的数据,并以一维数组或者矩阵返回(主要取决axis)
tofile(fid[, sep, format]) :将矩阵中的数据以二进制写入到文件
tolist() :将矩阵转化为列表形式
tostring([order]):将矩阵转化为python的字符串.
trace([offset, axis1, axis2, dtype, out]):返回对角线元素之和
transpose(*axes) :返回矩阵的转置矩阵，不改变原有矩阵
var([axis, dtype, out, ddof]) ：沿指定轴方向，返回矩阵元素的方差
view([dtype, type]) :生成一个相同数据，但是类型为指定新类型的矩阵。

ü All方法

a = np.asmatrix('0 2 7; 3 4 8; 5 0 9')
a.all()
False
a.all(axis=0)
matrix([[False, False, True]], dtype=bool)
a.all(axis=1)
matrix([[False],
[ True],
[False]], dtype=bool)

ü Astype方法

a.astype(float)
matrix([[ 12., 3., 5.],
[ 32., 23., 9.],
[ 10., -14., 78.]])

ü Argsort方法

a=np.matrix('12 3 5; 32 23 9; 10 -14 78')
a.argsort()
matrix([[1, 2, 0],
[2, 1, 0],
[1, 0, 2]])

ü Clip方法

a
matrix([[ 12, 3, 5],
[ 32, 23, 9],
[ 10, -14, 78]])
a.clip(12,32)
matrix([[12, 12, 12],
[32, 23, 12],
[12, 12, 32]])

ü Cumprod方法

a.cumprod(axis=1)
matrix([[ 12, 36, 180],
[ 32, 736, 6624],
[ 10, -140, -10920]])

ü Cumsum方法

a.cumsum(axis=1)
matrix([[12, 15, 20],
[32, 55, 64],
[10, -4, 74]])

ü Tolist方法

b.tolist()
[[12, 3, 5], [32, 23, 9], [10, -14, 78]]

ü Tofile方法

b.tofile('d:\b.txt')

ü compress()方法

from numpy import *
a = array([10, 20, 30, 40])
condition = (a > 15) & (a < 35)
condition
array([False, True, True, False], dtype=bool)
a.compress(condition)
array([20, 30])
a[condition] # same effect
array([20, 30])
compress(a >= 30, a) # this form a
so exists
array([30, 40])
b = array([[10,20,30],[40,50,60]])
b.compress(b.ravel() >= 22)
array([30, 40, 50, 60])
x = array([3,1,2])
y = array([50, 101])
b.compress(x >= 2, axis=1) # illustrates
the use of the axis keyword
array([[10, 30],
[40, 60]])
b.compress(y >= 100, axis=0)
array([[40, 50, 60]])