NumPy学习(让数据处理变简单)

NumPy学习（一）

NumPy数组创建

NumPy数组属性

NumPy数学算术与算数运算

NumPy数组创建

NumPy 中定义的最重要的对象是称为 ndarray 的 N 维数组类型。 它描述相同类型的元素集合。 可以使用基于零的索引访问集合中的项目。
ndarray中的每个元素在内存中使用相同大小的块。 ndarray中的每个元素是数据类型对象的对象(称为 dtype)。
从ndarray对象提取的任何元素(通过切片)由一个数组标量类型的 Python 对象表示。 

　　

它从任何暴露数组接口的对象，或从返回数组的任何方法创建一个ndarray。

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

序号	参数及描述
1.	object 任何暴露数组接口方法的对象都会返回一个数组或任何(嵌套)序列。
2.	dtype 数组的所需数据类型，可选。
3.	copy 可选，默认为true，对象是否被复制。
4.	order C(按行)、F(按列)或A(任意，默认)。
5.	subok 默认情况下，返回的数组被强制为基类数组。 如果为true，则返回子类。
6.	ndimin 指定返回数组的最小维数。

dtype用来设置元素的数据类型

NumPy 支持比 Python 更多种类的数值类型。 下表显示了 NumPy 中定义的不同标量数据类型。
序号	数据类型及描述
1.	bool_存储为一个字节的布尔值(真或假)
2.	int_默认整数，相当于 C 的long，通常为int32或int64
3.	intc相当于 C 的int，通常为int32或int64
4.	intp用于索引的整数，相当于 C 的size_t，通常为int32或int64
5.	int8字节(-128 ~ 127)
6.	int1616 位整数(-32768 ~ 32767)
7.	int3232 位整数(-2147483648 ~ 2147483647)
8.	int6464 位整数(-9223372036854775808 ~ 9223372036854775807)
9.	uint88 位无符号整数(0 ~ 255)
10.	uint1616 位无符号整数(0 ~ 65535)
11.	uint3232 位无符号整数(0 ~ 4294967295)
12.	uint6464 位无符号整数(0 ~ 18446744073709551615)
13.	float_float64的简写
14.	float16半精度浮点：符号位，5 位指数，10 位尾数
15.	float32单精度浮点：符号位，8 位指数，23 位尾数
16.	float64双精度浮点：符号位，11 位指数，52 位尾数
17.	complex_complex128的简写
18.	complex64复数，由两个 32 位浮点表示(实部和虚部)
19.	complex128复数，由两个 64 位浮点表示(实部和虚部)

　　

最简单的创建方式

import numpy as np

#将列表转为numpy的数组
array=np.array([[1,2,3],[4,5,6]])
print(array)

　

运行结果：

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

　　

1.

创建特殊数组

返回特定大小，以 0 填充的新数组。

numpy.zeros(shape, dtype = float, order = 'C')

import numpy as np

#定义一个三行四列全为零的矩阵
c=np.zeros((3,4))
print(c)

运算结果：

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

　　

2.

返回特定大小，以 1 填充的新数组。

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

import numpy as np
#定义一个3行2列全为1的矩阵
d=np.ones((3,2))
print(d)

运行结果：

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

3.

它创建指定形状和dtype的未初始化数组。 它使用以下构造函数：

numpy.empty(shape, dtype = float, order = 'C')

构造器接受下列参数：
序号	参数及描述
1.	Shape 空数组的形状，整数或整数元组
2.	Dtype 所需的输出数组类型，可选
3.	Order 'C'为按行的 C 风格数组，'F'为按列的 Fortran 风格数组

　　

import numpy as np
#生成一个空矩阵，还不懂这里的空到底指什么。。。
e=np.empty((3,1))
print(e)

运行结果：

[[1.443e-321]
 [0.000e+000]
 [0.000e+000]]

　

4.

此函数类似于arange()函数。 在此函数中，指定了范围之间的均匀间隔数量，而不是步长。 此函数的用法如下。

numpy.linspace(start, stop, num, endpoint, retstep, dtype)

import numpy as np
#将一段连续长大小为分几份
f=np.linspace(1,10,5) #这里的意思就是
print(f)

运行结果：

[ 1.    3.25  5.5   7.75 10.  ]

　　

5.

这个函数返回ndarray对象，包含给定范围内的等间隔值。

numpy.arange(start, stop, step, dtype)

import numpy as np
返回等间隔数字的数组
array2=np.arange(6) #一个参数，默认从零开始；两个参数，从第一个参数开始，到第二个参数，不包括第二个参数；三个参数，最后一个为间隔的大
小，默认为1
print(array2)

运行结果:

[0 1 2 3 4 5]

　　

6.

import numpy as np
f=np.random.random((2,4)) #生成两行四列的数组，每个元素大于0小于1
print(f)

运行结果:

[[0.92670103 0.92050586 0.67470818 0.61072068]
 [0.52409562 0.562209   0.08881487 0.06907785]]

　

NumPy数组属性及方法

ndarray.shape

这一数组属性返回一个包含数组维度的元组，它也可以用于调整数组大小。

ndarray.ndim

这一数组属性返回数组的维数。

numpy.itemsize

这一数组属性返回数组中每个元素的字节单位长度。

numpy.size

这一 数组属性返回数组中所有元素的个数

numpy.dtype()

返回数组元素的数据类型

numpy.flags

ndarray对象拥有以下属性。这个函数返回了它们的当前值。

序号	属性及描述
1.	C_CONTIGUOUS (C) 数组位于单一的、C 风格的连续区段内
2.	F_CONTIGUOUS (F) 数组位于单一的、Fortran 风格的连续区段内
3.	OWNDATA (O) 数组的内存从其它对象处借用
4.	WRITEABLE (W) 数据区域可写入。 将它设置为flase会锁定数据，使其只读
5.	ALIGNED (A) 数据和任何元素会为硬件适当对齐
6.	UPDATEIFCOPY (U) 这个数组是另一数组的副本。当这个数组释放时，源数组会由这个数组中的元素更

　　

程序示例：

import numpy as np

#将列表转为numpy的数组
array=np.array([[1,2,3],[4,5,6]])

print(array.ndim) #输出数组维度

#shape属性默认输出行列，也可以设置数组的行列 print(array.shape) #输出行列
#第一种设置行列的方法
array.shape =(3,2)
print(array)

#第二种设置行列的方法
array=array.reshape(2,3) #注意一定要重新赋值
print(array)

print(array.itemsize) #每个元素的字节长度单位，可以通过dtype参数设置
print(array.size) #所有元素的个数
print(array.flags) #展示当前的标志

　

运行结果

2
[[1 2]
 [3 4]
 [5 6]]
[[1 2 3]
 [4 5 6]]
4
6
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : False
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

　　

NumPy算数函数与算数运算

NumPy 包含大量的各种数学运算功能。 NumPy 提供标准的三角函数，算术运算的函数，复数处理函数等。

三角函数

NumPy 拥有标准的三角函数，它为弧度制单位的给定角度返回三角函数比值。

程序示例

import numpy as np
a = np.array([0,30,45,60,90])
print  '不同角度的正弦值：'
# 通过乘 pi/180 转化为弧度
print np.sin(a*np.pi/180)
print  '\n'
print  '数组中角度的余弦值：'
print np.cos(a*np.pi/180)
print  '\n'
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的反三角函数。 这些函数的结果可以通过numpy.degrees()函数通过将弧度制转换为角度制来验证。

程序示例

import numpy as np
a = np.array([0,30,45,60,90])
print ('含有正弦值的数组：')
sin = np.sin(a*np.pi/180)
print(sin)
print('计算角度的反正弦，返回值以弧度为单位：')
inv = np.arcsin(sin)
print(inv)
print ('通过转化为角度制来检查结果：')
print(np.degrees(inv))

运行结果

含有正弦值的数组：
[0.         0.5        0.70710678 0.8660254  1.        ]
计算角度的反正弦，返回值以弧度为单位：
[0.         0.52359878 0.78539816 1.04719755 1.57079633]
通过转化为角度制来检查结果：
[ 0. 30. 45. 60. 90.]

　

舍入函数

numpy.around()

这个函数返回四舍五入到所需精度的值。 
该函数接受以下参数。numpy.around(a,decimals)

序号	参数及描述
1.	a 输入数组
2.	decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

　　

程序示例

import numpy as np
a = np.array([1.0,5.55,  123,  0.567,  25.532])
print('原数组：')
print(a)
print('舍入后：')
print(np.around(a))
print np.around((a, decimals =  1))
print np.around((a, decimals =  -1))

　

运行结果

原数组：
[   1.       5.55   123.       0.567   25.532]

舍入后：
[   1.    6.   123.    1.   26. ]
[   1.    5.6  123.    0.6  25.5]
[   0.    10.  120.    0.   30. ]

　　

numpy.floor()

此函数返回不大于输入参数的最大整数。 即标量x 的下限是最大的整数i ，使得i <= x。 注意在Python中，向下取整总是从 0 舍入。
说这么多，就是向下取整，比如一个数：-1.7，向下取整为-2，向上取整为-1

import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])
print('提供的数组：')
print(a)
print('修改后的数组：')
print(np.floor(a))

提供的数组：
[-1.7 1.5 -0.2 0.6 10. ]
修改后的数组：
[-2. 1. -1. 0. 10.]

　

numpy.ceil()

ceil()函数返回输入值的上限，即，标量x的上限是最小的整数i ，使得i> = x。

就是向上取整。

算数运算

程序示例

import  numpy as np

#一维数组的简单计算
a= np.array([10,23,44,30])
b=np.arange(4)
print(a)
print(b)

#相同位置相加
c=a+b
print(c)

#乘法
c=a*b
print(c)

#b**2
c=b**2
print(c)

print(a<2)
print(a==2)

运行结果

[10 23 44 30]
[0 1 2 3]
[10 24 46 33]
[ 0 23 88 90]
[0 1 4 9]
[False False False False]
[False False False False]

　　

程序示例

import numpy as np
array1=np.array([[1,4],[4,8]])
array2=np.arange(4).reshape(2,2)

#这里依然对应位置相乘
d=array1*array2
print(d)

#矩阵的乘法
d=np.dot(array1,array2)
print(d)
d=array1.dot(array2)
print(d)

#1为行，0为列
f=np.random.random((2,4))
print(f)
print(np.sum(f))
print(np.min(f))
print(np.max(f))

print(np.sum(f,axis=1))
print(np.min(f,axis=0))
print(np.max(f,axis=1))

　　

运行结果

[[ 0  4]
 [ 8 24]]
[[ 8 13]
 [16 28]]
[[ 8 13]
 [16 28]]
[[0.81949136 0.53538773 0.98840439 0.80249925]
 [0.65929239 0.69338047 0.00943806 0.56616625]]
5.0740598977352835
0.009438059212795835
0.9884043925380781
[3.14578273 1.92827717]
[0.65929239 0.53538773 0.00943806 0.56616625]
[0.98840439 0.69338047]

　　

import numpy as np

# #将列表转为numpy的数组
array1=np.arange(2,14).reshape(3,4)
print(array1)
print('总和')
print(array1.sum())

print('最大最小值')
print(array1.max())
print(array1.min())

print('最大最小值的索引')
print(array1.argmin())
print(array1.argmax())

print('平均值')
print(array1.mean())
print(np.average((array1)))

print('分别计算行和列的平均值')
print(np.mean(array1,axis=0))
print(np.mean(array1,axis=1))

print('中位值')
print(np.median(array1))

print('累积值')
print(np.cumsum(array1))

print('前一项减后一项')
print(np.diff(array1))

print('数组中不为零的值')
print(np.nonzero(array1))
print(array1[np.nonzero(array1)])

print('数组中满足条件')
print(np.where(array1>10))
print(array1[np.where(array1>10)])

print('矩阵的转置')
print(np.transpose(array1))

print('所有大于9的元素等于9，所有小于5的元素等于5')
print(np.clip(array1,5,9))

　　

[[ 2  3  4  5]
 [ 6  7  8  9]
 [10 11 12 13]]
90
最大最小值
13
2
最大最小值的索引
0
11
平均值
7.5
7.5
分别计算行和列的平均值
[6. 7. 8. 9.]
[ 3.5  7.5 11.5]
中位值
7.5
累积值
[ 2  5  9 14 20 27 35 44 54 65 77 90]
前一项减后一项
[[1 1 1]
 [1 1 1]
 [1 1 1]]
数组中不为零的值
(array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2], dtype=int64), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3], dtype=int64))
[ 2  3  4  5  6  7  8  9 10 11 12 13]
数组中满足条件
(array([2, 2, 2], dtype=int64), array([1, 2, 3], dtype=int64))
[11 12 13]
矩阵的转置
[[ 2  6 10]
 [ 3  7 11]
 [ 4  8 12]
 [ 5  9 13]]
所有大于9的元素等于9，所有小于5的元素等于5
[[5 5 5 5]
 [6 7 8 9]
 [9 9 9 9]]

　　

用于执行算术运算(如add()，subtract()，multiply()和divide())的输入数组必须具有相同的形状或符合数组广播规则。

程序示例

import numpy as np
a = np.arange(9, dtype = np.float_).reshape(3,3)
print('第一个数组：'  )
print (a )

print ('第二个数组：' )
b = np.array([10,10,10])
print(b )
print('两个数组相加：')
print(np.add(a,b) )

print ('两个数组相减：'  )
print(np.subtract(a,b)  )

print ('两个数组相乘：'  )
print(np.multiply(a,b) )

print ('两个数组相除：' )
print(np.divide(a,b))

　

运行结果

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

第二个数组：
[10 10 10]

两个数组相加：
[[ 10. 11. 12.]
 [ 13. 14. 15.]
 [ 16. 17. 18.]]

两个数组相减：
[[-10. -9. -8.]
 [ -7. -6. -5.]
 [ -4. -3. -2.]]

两个数组相乘：
[[ 0. 10. 20.]
 [ 30. 40. 50.]
 [ 60. 70. 80.]]

两个数组相除：
[[ 0. 0.1 0.2]
 [ 0.3 0.4 0.5]
 [ 0.6 0.7 0.8]]