NumPy 基础

NumPy 基础

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

主要针对数字进行运算

NumPy 最重要的一个特点是其 N 维数组对象 ndarray


numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
参数说明：
object 数组或嵌套的数列
dtype 数组元素的数据类型，可选
copy 对象是否需要复制，可选
order 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok 默认返回一个与基类类型一致的数组
ndimin 指定生成数组的最小维度

a = np.array([1,2,3]) 
print (a)

[1, 2, 3]


a = np.array([[1,  2],  [3,  4]]) 
print (a)

[[1, 2]
[3, 4]]


轴的概念：
[0轴,1轴,2轴,........]


//===========================数据类型
bool_ 布尔型数据类型（True 或者 False）
int_ 默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc 与 C 的 int 类型一样，一般是 int32 或 int 64
intp 用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8 字节（-128 to 127）
int16 整数（-32768 to 32767）
int32 整数（-2147483648 to 2147483647）
int64 整数（-9223372036854775808 to 9223372036854775807）
uint8 无符号整数（0 to 255）
uint16 无符号整数（0 to 65535）
uint32 无符号整数（0 to 4294967295）
uint64 无符号整数（0 to 18446744073709551615）
float_ float64 类型的简写
float16 半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32 单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64 双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_ complex128 类型的简写，即 128 位复数
complex64 复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128 复数，表示双 64 位浮点数（实数部分和虚数部分）


numpy.dtype(object, align, copy)
object - 要转换为的数据类型对象
align - 如果为 true，填充字段使其类似 C 的结构体。
copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用

dt = np.dtype(np.int32)
print(dt)

int32

# int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替

#------将数据类型应用于 ndarray 对象
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print(a)

[(10,) (20,) (30,)]

#------定义一个结构化数据类型 student
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
print(student)

[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')]

a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student)
print(a)

[('abc', 21, 50.0), ('xyz', 18, 75.0)]

每个内建类型都有一个唯一定义它的字符代码:
b 布尔型
i (有符号) 整型
u 无符号整型 integer
f 浮点型
c 复数浮点型
m timedelta（时间间隔）
M datetime（日期时间）
O (Python) 对象
S, a (byte-)字符串
U Unicode
V 原始数据 (void)




//===========================数组属性
ndarray 对象属性有：

ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵，n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.itemsize	ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags	ndarray 对象的内存信息
ndarray.real	ndarray元素的实部
ndarray.image	ndarray 元素的虚部
ndarray.data	包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

#------reshape 函数来调整数组大小



//===========================创建数组
#------numpy.empty
numpy.empty(shape, dtype = float, order = 'C')

shape	数组形状
dtype	数据类型，可选
order	有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

数组元素为随机值，因为它们未初始化。

#------numpy.zeros
创建指定大小的数组，数组元素以 0 来填充：
umpy.zeros(shape, dtype = float, order = 'C')

#------numpy.ones
numpy.ones(shape, dtype = None, order = 'C')


//===========================从已有的数组创建数组
#------numpy.asarray
numpy.asarray(a, dtype = None, order = None)

a	任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
dtype	数据类型，可选
order	可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

x =  [1,2,3]
a = np.asarray(x) 
print (a)

[1  2  3]

#------numpy.frombuffer
接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

buffer	可以是任意对象，会以流的形式读入。
dtype	返回数组的数据类型，可选
count	读取的数据数量，默认为-1，读取所有数据。
offset	读取的起始位置，默认为0。

s =  b'Hello World'
a = np.frombuffer(s, dtype =  'S1') 
print (a)

[b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']

s =  'Hello World'
a = np.frombuffer(s, dtype =  'S1')
print (a)

['H' 'e' 'l' 'l' 'o' ' ' 'W' 'o' 'r' 'l' 'd']

#------numpy.fromiter
numpy.fromiter(iterable, dtype, count=-1)

iterable	可迭代对象
dtype	返回数组的数据类型
count	读取的数据数量，默认为-1，读取所有数据

list=range(5)
it=iter(list)

# 使用迭代器创建 ndarray
x=np.fromiter(it, dtype=float)
print(x)

[0. 1. 2. 3. 4.]

//===========================从数值范围创建数组
#------numpy.arange
numpy.arange(start, stop, step, dtype)

start	起始值，默认为0
stop	终止值（不包含）
step	步长，默认为1
dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

x = np.arange(5, dtype =  float) 
print (x)

[0.  1.  2.  3.  4.]

x = np.arange(10,20,2)

[10  12  14  16  18]

#------numpy.linspace
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

start	序列的起始值
stop	序列的终止值，如果endpoint为true，该值包含于数列中
num	要生成的等步长的样本数量，默认为50
endpoint	该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
retstep	如果为 True 时，生成的数组中会显示间距，反之不显示。
dtype	ndarray 的数据类型

a = np.linspace(1,10,10)
print(a)

[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

#------numpy.logspace
创建一个等比数列
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

start	序列的起始值为：base ** start
stop	序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
num	要生成的等步长的样本数量，默认为50
endpoint	该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
base	对数 log 的底数。
dtype	ndarray 的数据类型

将对数的底数设置为2:(多小就是等比的值)
a = a = np.logspace(0,9,10,base=2)
print (a)

[  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]

//===========================切片和索引(设置 start, stop 及 step 参数)
#------slice
s = slice(2,7,2)   # 从索引 2 开始到索引 7 停止，间隔为2
print (a[s])


#------通过冒号分隔切片参数 start:stop:step
a[第二维(开始：结束：步长),第一维(开始：结束：步长)]

a = np.arange(10) 
b = a[2:7:2]   # 从索引 2 开始到索引 7 停止，间隔为 2
print(b)

[2  4  6]

a[5] #返回元素
print(a[2:]) #返回该索引开始以后的所有元素
print(a[2:5]) #定好开始和结束，不包括结束


#------省略号 …(在那个位置就表示与那个维度数相同)
选择元组的长度与数组的维度相同

print (a[...,1])   # 第2列元素
print (a[1,...])   # 第2行元素
print (a[...,1:])  # 第2列及剩下的所有元素

[2 4 5]
[3 4 5]
[[2 3]
 [4 5]
 [5 6]]

//===========================高级索引
#------整数数组索引
x = np.array([[1,  2],  [3,  4],  [5,  6]])
y = x[[0,1,2],  [0,1,0]]   #[0,1,0]代表第一维和索引,[0,1,2]代表第二维和索引
print (y)

[1  4  5]

#------借助切片 : 或 … 与索引数组组合
a[第二维(开始：结束：步长),第一维(开始：结束：步长)]

a = np.array([[1,2,3], [4,5,6],[7,8,9]])
b = a[1:3, 1:3]
c = a[1:3,[1,2]]
d = a[...,1:]
print(b)
print(c)
print(d)

[[5 6]
 [8 9]]
[[5 6]
 [8 9]]
[[2 3]
 [5 6]
 [8 9]]

#------布尔索引
print (x[x >  5]) #直接返回元素数组

大于 5 的元素是：
[ 6  7  8  9 10 11]

#------ ~（取补运算符）
a = np.array([np.nan,  1,2,np.nan,3,4,5]) 
print (a[~np.isnan(a)])

[ 1.   2.   3.   4.   5.]

a = np.array([1,  2+6j,  5,  3.5+5j]) 
print (a[np.iscomplex(a)])

[2.0+6.j  3.5+5.j]

#------ 花式索引
花式索引跟切片不一样，它总是将数据复制到新数组中。
花式索引指的是利用整数数组进行索引。
花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；如果目标是二维数组，那么就是对应下标的行。

x=np.arange(32).reshape((8,4))
print (x[[4,2,1,7]])

[[16 17 18 19]
 [ 8  9 10 11]
 [ 4  5  6  7]
 [28 29 30 31]]

#------ 倒序索引数组
x=np.arange(32).reshape((8,4))
print (x[[-4,-2,-1,-7]])

[[16 17 18 19]
 [24 25 26 27]
 [28 29 30 31]
 [ 4  5  6  7]]

#------ 传入多个索引数组（要使用np.ix_）
x=np.arange(32).reshape((8,4))
print (x[np.ix_([1,5,7,2],[0,3,1,2])])

实际意思就是，直接往np.ix_()里扔进两个一维数组[1,5,7,2]，[0,3,1,2]，就能先按我们要求选取行，再按顺序将列排序，跟上面得到的结果一样，而不用写“[ : , [0,3,1,2] ]”

[[ 4  7  5  6]
 [20 23 21 22]
 [28 31 29 30]
 [ 8 11  9 10]]

print (x[[1,5,7,2]][:,[0,3,1,2]])#输出结果一样



//===========================迭代数组
for x in np.nditer(a): #迭代的是每个元素


#------ 控制遍历顺序
for x in np.nditer(a, order='F'):Fortran order，即是列序优先；
for x in np.nditer(a.T, order='C'):C order，即是行序优先；



#------ 修改数组中元素的值
默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only）
for x in np.nditer(a, op_flags=['readwrite']):


#------使用外部循环,
c_index 可以跟踪 C 顺序的索引
f_index 可以跟踪 Fortran 顺序的索引
multi-index 每次迭代可以跟踪一种索引类型
external_loop 给出的值是具有多个值的一维数组，而不是零维数组

for x in np.nditer(a, flags =  ['external_loop'], order =  'F'): 


#------广播迭代
a = np.arange(0,60,5)
a = a.reshape(3,4) 
print  ('第一个数组为：')
print (a)
print  ('\n')
print ('第二个数组为：')
b = np.array([1,  2,  3,  4], dtype =  int) 
print (b)
print ('\n')
print ('修改后的数组为：')
for x,y in np.nditer([a,b]): 
    print ("%d:%d"  %  (x,y), end=", " )

第一个数组为：
[[ 0  5 10 15]
 [20 25 30 35]
 [40 45 50 55]]


第二个数组为：
[1 2 3 4]


修改后的数组为：
0:1, 5:2, 10:3, 15:4, 20:1, 25:2, 30:3, 35:4, 40:1, 45:2, 50:3, 55:4,

//===========================数组操作
#------修改数组形状
reshape 不改变数据的条件下修改形状
flat 数组元素迭代器
flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
ravel 返回展开数组

b = a.reshape(4,2)

order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序。

#------数组元素迭代器
for element in a.flat:

#------展开的数组
a.flatten()

order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。

a = np.arange(8).reshape(2,4)

print ('原数组：')
print (a)
print ('\n')
# 默认按行

print ('展开的数组：')
print (a.flatten())
print ('\n')

print ('以 F 风格顺序展开的数组：')
print (a.flatten(order = 'F'))

原数组：
[[0 1 2 3]
 [4 5 6 7]]


展开的数组：
[0 1 2 3 4 5 6 7]


以 F 风格顺序展开的数组：
[0 4 1 5 2 6 3 7]

#------展平的数组元素
顺序通常是"C风格"，返回的是数组视图（view），修改会影响原始数组。

order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。

a.ravel()

[0 1 2 3 4 5 6 7]

#------翻转数组
transpose 对换数组的维度
ndarray.T 和 self.transpose() 相同
rollaxis 向后滚动指定的轴
swapaxes 对换数组的两个轴

对换数组的维度
np.transpose(a)

a.T  =====> np.transpose(a)

向后滚动特定的轴到一个特定位置
numpy.rollaxis(arr, axis, start)

以索引为轴的:https://blog.csdn.net/kieven2008/article/details/80035668


arr：数组
axis：要向后滚动的轴，其它轴的相对位置不会改变
start：默认为零，表示完整的滚动。会滚动到特定位置。

print (np.rollaxis(a,2))
print (np.rollaxis(a,2,1))



交换数组的两个轴
numpy.swapaxes(arr, axis1, axis2)

arr：输入的数组
axis1：对应第一个轴的整数
axis2：对应第二个轴的整数



#------修改数组维度
broadcast 产生模仿广播的对象
broadcast_to 将数组广播到新形状
expand_dims 扩展数组的形状
squeeze 从数组的形状中删除一维条目

????????????????????????????



#------连接数组
concatenate 连接沿现有轴的数组序列
stack 沿着新的轴加入一系列数组。
hstack 水平堆叠序列中的数组（列方向）
vstack 竖直堆叠序列中的数组（行方向）

numpy.concatenate((a1, a2, ...), axis)
a1, a2, ...：相同类型的数组
axis：沿着它连接数组的轴，默认为 0

np.concatenate((a,b)) #沿行索引加入
np.concatenate((a,b),axis = 1) ##沿列索引加入


stack  沿新轴连接数组序列
numpy.stack(arrays, axis)

arrays相同形状的数组序列
axis：返回数组中的轴，输入数组沿着它来堆叠



hstack 通过水平方向堆叠来生成数组
np.hstack((a,b))

第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


水平堆叠：
[[1 2 5 6]
 [3 4 7 8]]

vstack 通过垂直方向堆叠来生成数组
np.vstack((a,b))

第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


竖直堆叠：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

#------分割数组
split 将一个数组分割为多个子数组
hsplit 将一个数组水平分割为多个子数组（按列）
vsplit 将一个数组垂直分割为多个子数组（按行）

numpy.split(ary, indices_or_sections, axis)

ary：被分割的数组
indices_or_sections：果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
axis：沿着哪个维度进行切向，默认为0，横向切分。为1时，纵向切分


用于水平方向分割数组
np.hsplit(harr, 3)


沿着垂直方向分割
np.vsplit(a,2)


#------数组元素的添加与删除
resize 返回指定形状的新数组
append 将值添加到数组末尾
insert 沿指定轴将值插入到指定下标之前
delete 删掉某个轴的子数组，并返回删除后的新数组
unique 查找数组内的唯一元素


np.resize(a, (3,2))

b = np.resize(a,(3,3)) #不够大的，重复一次获取(从0开始)


在数组的末尾添加值
print (np.append(a, [7,8,9])) #向数组添加元素

print (np.append(a, [[7,8,9]],axis = 0)) #沿轴 0 添加元素

print (np.append(a, [[5,5,5],[7,8,9]],axis = 1)) #沿轴 1 添加元素


在给定索引之前，沿给定轴在输入数组中插入值。
numpy.insert(arr, obj, values, axis)

arr：输入数组
obj：在其之前插入值的索引
values：要插入的值
axis：沿着它插入的轴，如果未提供，则输入数组会被展开


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

print ('第一个数组：')
print (a)
print ('\n')

print ('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print (np.insert(a,3,[11,12]))
print ('\n')
print ('传递了 Axis 参数。 会广播值数组来配输入数组。')

print ('沿轴 0 广播：')
print (np.insert(a,1,[11],axis = 0))
print ('\n')

print ('沿轴 1 广播：')
print (np.insert(a,1,11,axis = 1))

第一个数组：
[[1 2]
 [3 4]
 [5 6]]


未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 1  2  3 11 12  4  5  6]


传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴 0 广播：
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]


沿轴 1 广播：
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]

返回从输入数组中删除指定子数组的新数组
Numpy.delete(arr, obj, axis)
arr：输入数组
obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开

a = np.arange(12).reshape(3,4)

print ('第一个数组：')
print (a)
print ('\n')

print ('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print (np.delete(a,5))
print ('\n')

print ('删除第二列：')
print (np.delete(a,1,axis = 1))
print ('\n')

print ('包含从数组中删除的替代值的切片：')
a = np.array([1,2,3,4,5,6,7,8,9,10])
print (np.delete(a, np.s_[::2]))

第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0  1  2  3  4  6  7  8  9 10 11]


删除第二列：
[[ 0  2  3]
 [ 4  6  7]
 [ 8 10 11]]


包含从数组中删除的替代值的切片：
[ 2  4  6  8 10]

去除数组中的重复元素
numpy.unique(arr, return_index, return_inverse, return_counts)
arr：输入数组，如果不是一维数组则会展开
return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

np.unique(a)

去重数组的索引数组
u,indices = np.unique(a, return_index = True)

去重数组的下标
u,indices = np.unique(a,return_inverse = True)


使用下标重构原数组
u[indices]

返回去重元素的重复数量
u,indices = np.unique(a,return_counts = True)



//===========================字符串函数
add() 对两个数组的逐个字符串元素进行连接
multiply() 返回按元素多重连接后的字符串
center() 居中字符串
capitalize() 将字符串第一个字母转换为大写
title() 将字符串的每个单词的第一个字母转换为大写
lower() 数组元素转换为小写
upper() 数组元素转换为大写
split() 指定分隔符对字符串进行分割，并返回数组列表
splitlines() 返回元素中的行列表，以换行符分割
strip() 移除元素开头或者结尾处的特定字符
join() 通过指定分隔符来连接数组中的元素
replace() 使用新字符串替换字符串中的所有子字符串
decode() 数组元素依次调用str.decode
encode() 数组元素依次调用str.encode


#------字符串连接
print (np.char.add(['hello'],[' xyz']))

['hello xyz']

print (np.char.add(['hello', 'hi'],[' abc', ' xyz']))

['hello abc' 'hi xyz']

#------执行多重连接
print (np.char.multiply('Runoob ',3))

Runoob Runoob Runoob 

#------将字符串居中，并使用指定字符在左侧和右侧进行填充。
# str: 字符串，width: 长度，fillchar: 填充字符
print (np.char.center('Runoob', 20,fillchar = '*'))

*******Runoob*******

#------第一个字母转换为大写
print (np.char.capitalize('runoob'))

Runoob

#------将字符串的每个单词的第一个字母转换为大写
print (np.char.title('i like runoob'))

I Like Runoob

#------对数组的每个元素转换为小写
print (np.char.lower(['RUNOOB','GOOGLE']))

['runoob' 'google']

print (np.char.lower('RUNOOB'))

runoob

#------对数组的每个元素转换为大写
print (np.char.upper(['runoob','google']))

['RUNOOB' 'GOOGLE']

#------
指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格。
print (np.char.split ('i like runoob?'))

['i', 'like', 'runoob?']

print (np.char.split ('www.runoob.com', sep = '.'))

['www', 'runoob', 'com']

#------以换行符作为分隔符来分割字符串，并返回数组。
\n，\r，\r\n 都可用作换行符。

print (np.char.splitlines('i\nlike runoob?'))
print (np.char.splitlines('i\rlike runoob?'))

['i', 'like runoob?']
['i', 'like runoob?']

#------用于移除开头或结尾处的特定字符
# 移除字符串头尾的 a 字符
print (np.char.strip('ashok arunooba','a'))

# 移除数组元素头尾的 a 字符
print (np.char.strip(['arunooba','admin','java'],'a'))

shok arunoob
['runoob' 'dmin' 'jav']

#------通过指定分隔符来连接数组中的元素或字符串
# 操作字符串
print (np.char.join(':','runoob'))

# 指定多个分隔符操作数组元素
print (np.char.join([':','-'],['runoob','google']))

r:u:n:o:o:b
['r:u:n:o:o:b' 'g-o-o-g-l-e']

#------使用新字符串替换字符串中的所有子字符串。
print (np.char.replace ('i like runoob', 'oo', 'cc'))

i like runccb

#------默认编码是 utf-8，可以使用标准 Python 库中的编解码器。
a = np.char.encode('runoob', 'cp500')

b'\x99\xa4\x95\x96\x96\x82'

a = np.char.encode('runoob', 'cp500')
print (a)
print (np.char.decode(a,'cp500'))

b'\x99\xa4\x95\x96\x96\x82'
runoob

//===========================数学函数
包括三角函数，算术运算的函数，复数处理函数等。

a = np.array([0,30,45,60,90])
print (np.sin(a*np.pi/180))

print ('数组中角度的余弦值：')
print (np.cos(a*np.pi/180))

print ('数组中角度的正切值：')
print (np.tan(a*np.pi/180))

不同角度的正弦值：
[0.         0.5        0.70710678 0.8660254  1.        ]

数组中角度的余弦值：
[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
 6.12323400e-17]

数组中角度的正切值：
[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
 1.63312394e+16]

arcsin，arccos，和 arctan 函数返回给定角度的 sin，cos 和 tan 的反三角函数。

inv = np.arcsin(sin) 

numpy.degrees() 函数将弧度转换为角度。

print (np.degrees(inv))



#------舍入函数
返回指定数字的四舍五入值。
numpy.around(a,decimals)
a: 数组
decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

a = np.array([1.0,5.55,  123,  0.567,  25.532]) 
print (np.around(a))
print (np.around(a, decimals =  1))
print (np.around(a, decimals =  -1))

[  1.   6. 123.   1.  26.]
[  1.    5.6 123.    0.6  25.5]
[  0.  10. 120.   0.  30.]

#------数字的下舍整数。
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])
print (np.floor(a))

[-2.  1. -1.  0. 10.]

#------返回数字的上入整数。
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10]) 
print (np.ceil(a))

[-1.  2. -0.  1. 10.]

//===========================算术函数
#------加减乘除: add()，subtract()，multiply() 和 divide()。

print ('两个数组相加：')
print (np.add(a,b))
print ('两个数组相减：')
print (np.subtract(a,b))
print ('两个数组相乘：')
print (np.multiply(a,b))
print ('两个数组相除：')
print (np.divide(a,b))

#------返回参数逐元素的倒数
a = np.array([0.25,  1.33,  1,  100])
print (np.reciprocal(a))

[4.        0.7518797 1.        0.01     ]

#------将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。
a = np.array([10,100,1000]) 

print ('调用 power 函数：')
print (np.power(a,2))

print ('第二个数组：')
b = np.array([1,2,3]) 
print (b)

print ('再次调用 power 函数：')
print (np.power(a,b))

调用 power 函数：
[    100   10000 1000000]

第二个数组：
[1 2 3]

再次调用 power 函数：
[        10      10000 1000000000]

#------计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。

a = np.array([10,20,30])
b = np.array([3,5,7])

print (np.mod(a,b))
print (np.remainder(a,b))

调用 mod() 函数：
[1 0 2]
调用 remainder() 函数：
[1 0 2]

//===========================统计函数
#------从给定数组中的元素沿指定轴返回最小值和最大值
numpy.amin() 和 numpy.amax()

print np.amin(a,1)  #axis=1,1轴的最小值

print np.amin(a,0)  #axis=0,0轴的最小值

print np.amax(a) #所有元素的最大值

print np.amax(a, axis =  0) #axis=0,0轴的最大值


#------返回沿轴的值的范围(最大值 - 最小值)
print np.ptp(a) #所有元素的范围(最大值 - 最小值)

print np.ptp(a, axis =  1)  #axis=1,1轴的范围

print np.ptp(a, axis =  0)  #axis=0,0轴的范围


#------求取a数列第几分位的数值
numpy.percentile(a, q, axis)
a 输入数组
q 要计算的百分位数，在 0 ~ 100 之间
axis 沿着它计算百分位数的轴

print np.percentile(a,50)  #
print np.percentile(a,50, axis =  1)
print np.percentile(a,50, axis =  0)


#------将数据样本的上半部分与下半部分分开的值
numpy.median()

print np.median(a)  
print np.median(a, axis =  0) 
print np.median(a, axis =  1)



#------数组中元素的算术平均值
print np.mean(a) 

print np.mean(a, axis =  0) 

print np.mean(a, axis =  1)



#------加权平均值是由每个分量乘以反映其重要性的因子得到的平均值
加权平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1) #(4+3+2+1)加权和


print np.average(a) #不指定权重时相当于 mean 函数

wts = np.array([4,3,2,1]) 
print np.average(a,weights = wts)

print np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True) #同时返回权重的和

权重的和：
(2.0, 10.0)

print np.average(a, axis =  1, weights = wt)
print np.average(a, axis =  1, weights = wt, returned =  True)



#------标准差
标准差是与均值的偏差的平方的平均值的平方根。(方差后的开方),标准差是方差的平方根。
print np.std([1,2,3,4])

#------方差
方差是偏差的平方的平均值
print np.var([1,2,3,4])


//===========================排序、搜索和计数函数
#------返回输入数组的排序副本,按值大小排序
numpy.sort(a, axis, kind, order)
a 要排序的数组
axis 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序,，0表示按行，1表示按列，None表示展开来排序，默认值为-1，表示沿最后的轴排序
kind 默认为'quicksort'(快速排序)
order 如果数组包含字段，则是要排序的字段

print np.sort(a) 
print np.sort(a, axis =  0) 

我们的数组是：
[[3 7]
 [9 1]]

调用 sort() 函数：
[[3 7]
 [1 9]]

沿轴 0 排序：
[[3 1]
 [9 7]]

dt = np.dtype([('name',  'S10'),('age',  int)])
a = np.array([("raju",21),("anil",25),("ravi",  17),  ("amar",27)], dtype = dt) 
print  '我们的数组是：' 
print a
print  '按 name 排序：' 
print np.sort(a, order =  'name')

我们的数组是：
[('raju', 21) ('anil', 25) ('ravi', 17) ('amar', 27)]

按 name 排序：
[('amar', 27) ('anil', 25) ('raju', 21) ('ravi', 17)]

y = np.argsort(x) #返回的是数组值从小到大的索引值

numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。

numpy.nonzero() #函数返回输入数组中非零元素的索引。

(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))

numpy.where() 函数返回输入数组中满足给定条件的元素的索引。

(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))

numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。
????????????????????



//===========================副本和视图
副本是一个数据的完整的拷贝


#------视图或浅拷贝
创建一个新的数组对象，该方法创建的新数组的维数更改不会更改原始数据的维数。
b = a.view()

#------副本或深拷贝
ndarray.copy() 函数创建一个副本,对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。
b = a.copy()


//===========================矩阵库(Matrix)
NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。

numpy.matlib.empty(shape, dtype, order)
shape: 定义新矩阵形状的整数或整数元组
Dtype: 可选，数据类型
order: C（行序优先） 或者 F（列序优先）

print (np.matlib.empty((2,2)))
# 填充为随机数据


print (np.matlib.zeros((2,2)))

[[0. 0.]
 [0. 0.]]

numpy.matlib.ones()函数创建一个以 1 填充的矩阵。

[[1. 1.]
 [1. 1.]]

numpy.matlib.eye() 函数返回一个矩阵，对角线元素为 1，其他位置为零。
numpy.matlib.eye(n, M,k, dtype)
n: 返回矩阵的行数
M: 返回矩阵的列数，默认为 n
k: 对角线的索引
dtype: 数据类型

print (np.matlib.eye(n =  3, M =  4, k =  0, dtype =  float))

[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]]

numpy.matlib.identity() 函数返回给定大小的单位矩阵。
print (np.matlib.identity(5, dtype =  float))

[[ 1.  0.  0.  0.  0.] 
 [ 0.  1.  0.  0.  0.] 
 [ 0.  0.  1.  0.  0.] 
 [ 0.  0.  0.  1.  0.] 
 [ 0.  0.  0.  0.  1.]]

numpy.matlib.rand() 函数创建一个给定大小的矩阵，数据是随机填充的。
print (np.matlib.rand(3,3))

[[0.23966718 0.16147628 0.14162   ]
 [0.28379085 0.59934741 0.62985825]
 [0.99527238 0.11137883 0.41105367]]

矩阵总是二维的，而 ndarray 是一个 n 维数组。
i = np.matrix('1,2;3,4') 
print (i)

[[1  2] 
 [3  4]]

j = np.asarray(i) 
print (j)

[[1  2] 
 [3  4]]

k = np.asmatrix (j) 
print (k)

[[1  2] 
 [3  4]]

//===========================线性代数
NumPy 提供了线性代数函数库 linalg
dot 两个数组的点积，即元素对应相乘。
vdot 两个向量的点积
inner 两个数组的内积
matmul 两个数组的矩阵积
determinant 数组的行列式
solve 求解线性矩阵方程
inv 计算矩阵的乘法逆矩阵

?????????????????????????????



//===========================NumPy IO