python数据处理与分析入门-Numpy（1）

NumPy - 简介

NumPy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。Numeric，即 NumPy 的前身，是由 Jim Hugunin 开发的。 也开发了另一个包 Numarray ，它拥有一些额外的功能。 2005年，Travis Oliphant 通过将 Numarray 的功能集成到 Numeric 包中来创建 NumPy 包。 这个开源项目有很多贡献者。

NumPy 操作

使用NumPy，开发人员可以执行以下操作：

1. 数组的算数和逻辑运算。
2. 傅立叶变换和用于图形操作的例程。
3. 与线性代数有关的操作。 NumPy 拥有线性代数和随机数生成的内置函数。

ndarray

NumPy 中定义的最重要的对象是称为 ndarray 的 N 维数组类型。 它描述相同类型的元素集合。 可以使用基于零的索引访问集合中的项目。

import numpy as np
# 定义矩阵变量并输出变量的一些属性
# 用np.array()生成矩阵
arr=np.array([[1,2,3],
              [4,5,6]])
print(arr)
print('维度: ',arr.ndim)
print('形状: ',arr.shape)
print('大小: ', arr.size)
# 输出
[[1 2 3]
 [4 5 6]]
维度:  2
形状:  (2, 3)
大小:  6

# 定义一些特殊矩阵
# 指定矩阵数据类型
arr=np.array([[1,2,3],
              [4,5,6]],
              dtype=np.float64) 
print(arr.dtype)

# 用np.zeros()生成全零矩阵
arr_zeros=np.zeros( (2,3) )
print(arr_zeros)

# 用np.ones()生成全一矩阵
arr_ones=np.ones( (2,3) )
print(arr_ones)

# 用np.arange()生成数列
arr=np.arange(6,12)
print(arr)
# 输出
float64
[[0. 0. 0.]
 [0. 0. 0.]]
[[1. 1. 1.]
 [1. 1. 1.]]
[ 6  7  8  9 10 11]

NumPy - 数据类型

序号 数据类型及描述

1. bool_存储为一个字节的布尔值(真或假)
2. int_默认整数，相当于 C 的long，通常为int32或int64
3. intc相当于 C 的int，通常为int32或int64
4. intp用于索引的整数，相当于 C 的size_t，通常为int32或int64
5. int8 8字节(-128 ~ 127)
6. int16 16 位整数(-32768 ~ 32767)
7. int32 32 位整数(-2147483648 ~ 2147483647)
8. int64 64 位整数(-9223372036854775808 ~ 9223372036854775807)
9. uint8 8 位无符号整数(0 ~ 255)
10. uint16 16 位无符号整数(0 ~ 65535)
11. uint32 32 位无符号整数(0 ~ 4294967295)
12. uint64 64 位无符号整数(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 位浮点表示(实部和虚部)

#int8，int16，int32，int64 可替换为等价的字符串 'i1'，'i2'，'i4'，以及其他。 

dt = np.dtype('i4')
print(dt) # int32

NumPy - 切片和索引

ndarray对象的内容可以通过索引或切片来访问和修改，就像 Python 的内置容器对象一样。

a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print(a)
# 对始于索引的元素进行切片  
print('现在我们从索引 a[1:] 开始对数组切片')
print(a[1:])

# 现在我们从第二行切片所有元素：  
print ('第二行的元素是：')
print (a[1,...])  
# 输出
[[1 2 3]
 [3 4 5]
 [4 5 6]]
现在我们从索引 a[1:] 开始对数组切片
[[3 4 5]
 [4 5 6]]
第二行的元素是：
[3 4 5]

NumPy - 广播

术语广播是指 NumPy 在算术运算期间处理不同形状的数组的能力。 对数组的算术运算通常在相应的元素上进行。 如果两个阵列具有完全相同的形状，则这些操作被无缝执行。

a = np.array([1,2,3,4]) 
b = np.array([10,20,30,40]) 
c = a * b 
print(c) # [ 10  40  90 160]

如果两个数组的维数不相同，则元素到元素的操作是不可能的。 然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。 较小的数组会广播到较大数组的大小，以便使它们的形状可兼容。

如果满足以下规则，可以进行广播：

1. ndim较小的数组会在前面追加一个长度为 1 的维度。
2. 输出数组的每个维度的大小是输入数组该维度大小的最大值。
3. 如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它。
4. 如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算。

如果上述规则产生有效结果，并且满足以下条件之一，那么数组被称为可广播的。

1. 数组拥有相同形状。
2. 数组拥有相同的维数，每个维度拥有相同长度，或者长度为 1。
3. 数组拥有极少的维度，可以在其前面追加长度为 1 的维度，使上述条件成立。

a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]]) 
b = np.array([[1.0],[2],[3],[4]])  
#b = np.array([1.0])
#b = np.array([1.0,2,3])
print('第一个数组：'  )
print(a) 
print('\n'  )
print('第二个数组：'  )
print(b) 
print('\n')  
print('第一个数组加第二个数组：')
print(a + b)
# 输出
第一个数组：
[[ 0.  0.  0.]
 [10. 10. 10.]
 [20. 20. 20.]
 [30. 30. 30.]]


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


第一个数组加第二个数组：
[[ 1.  1.  1.]
 [12. 12. 12.]
 [23. 23. 23.]
 [34. 34. 34.]]

更多内容请查看我的gittee仓库 ： Python基础练习