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

 

NumPy学习（一）

 

NumPy数组创建

NumPy数组属性

NumPy数学算术与算数运算

 

 

NumPy数组创建

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

　　

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

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

 

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

 

 

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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 位浮点表示(实部和虚部)

　　

 

最简单的创建方式

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

　

?
1
运行结果：
?
1
2
[[1 2 3]
[4 5 6]]

　　

1.

创建特殊数组

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

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

?
1
2
import numpy as np#定义一个三行四列全为零的矩阵
c=np.zeros((3,4))<br>print(c)<br><br>

 

运算结果：

?
1
2
3
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

　　

 

2.

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

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

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

 

 

运行结果：

?
1
2
3
[[1. 1.]
 [1. 1.]
 [1. 1.]]

 

 

3.

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

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

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

　　

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

 

运行结果：

?
1
2
3
[[1.443e-321]
 [0.000e+000]
 [0.000e+000]]

　

 

4.

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

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

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

 

运行结果：

?
1
[ 1.    3.25  5.5   7.75 10.  ]

　　

 

5.

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

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

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

 

运行结果:

?
1
[0 1 2 3 4 5]

　　

 

6.

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

 

运行结果:

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

　　

 

程序示例：

?
1
2
3
4
5
6
7
8
9
10
11
import numpy as np
 
#将列表转为numpy的数组
array=np.array([[1,2,3],[4,5,6]])print(array.ndim) #输出数组维度#shape属性默认输出行列，也可以设置数组的行列 print(array.shape) #输出行列<br>
#第一种设置行列的方法
array.shape =(3,2)
print(array)
 
#第二种设置行列的方法
array=array.reshape(2,3) #注意一定要重新赋值
print(array)<br><br>print(array.itemsize) #每个元素的字节长度单位，可以通过dtype参数设置<br>print(array.size) #所有元素的个数<br>print(array.flags) #展示当前的标志

　

 

运行结果

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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 拥有标准的三角函数，它为弧度制单位的给定角度返回三角函数比值。

 

程序示例

?
1
2
3
4
5
6
7
8
9
10
11
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)

　

　

运行结果

?
1
2
3
4
5
6
7
8
9
10
不同角度的正弦值：                                                  
[ 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()函数通过将弧度制转换为角度制来验证。

 

程序示例

?
1
2
3
4
5
6
7
8
9
10
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))

 

运行结果

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

　

 

 

舍入函数

numpy.around()

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

 

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

　　

 

程序示例

?
1
2
3
4
5
6
7
8
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
2
3
4
5
6
7
原数组：                                                         
[   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()

?
1
此函数返回不大于输入参数的最大整数。 即标量x 的下限是最大的整数i ，使得i <= x。 注意在Python中，向下取整总是从 0 舍入。<br>说这么多，就是向下取整，比如一个数：-1.7，向下取整为-2，向上取整为-1<br><br>
?
1
2
3
4
5
6
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
2
3
4
提供的数组：
[-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)

 

 

运行结果

?
1
2
3
4
5
6
7
[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]

　　

 

程序示例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<br><br>import numpy as np<br>
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))

　　

 

 

运行结果

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
[[ 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]

　　

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
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))

　　

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
[[ 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]]

　　

 

 

?
1
用于执行算术运算(如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))

　

 

运行结果

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
第一个数组：
[[ 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]]

　　

 

posted @   -零  阅读(957)  评论(0)  编辑  收藏  举报
编辑推荐：
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？
点击右上角即可分享
微信分享提示
SQL AI 助手