Numpy 简介
- numpy 是 python 语言的一个 library
- 只支持矩阵操作和运算
- 由C语言写成，非常高效
- pandas 也是基于 Numpy 构建的一个 library
- 现在流行的机器学习框架 Tensorflow/PyTorch 等等，语法都与 Numpy 比较接近
如何生成一个ndarray
# -*- coding:utf8 -*-
import numpy as np
def array_1():
"""用 numpy.array 从 list 初始化一个数组"""
li = [1, 2, 3, 4]
array = np.array(li)
print(array, type(array)) # [1 2 3 4] <class 'numpy.ndarray'>
# 取值
print(array[0]) # 1
# 赋值
array[0] = 99
print(array[0]) # 99
def array_2():
"""构建一个2维的 array"""
li = [[1, 2, 3], [4, 5, 6]]
array = np.array(li)
print(array, type(array)) # [[1 2 3] [4 5 6]] <class 'numpy.ndarray'>
# 查看 array 的 shape (形状)
print(array.shape) # (2, 3)
# 从二维数组获取 element
print(array[0][1]) # 2
print(array[0, 1]) # 2
def array_3():
"""用内置函数创建 array"""
# 构建一个 element 全是 0 的 array
array = np.zeros((2, 3))
print(array, array.shape) # [[0. 0. 0.] [0. 0. 0.]] (2, 3)
# 构建一个 element 全都是 1 的 array
array = np.ones((1, 2))
print(array, array.shape) # [[1. 1.]] (1, 2)
# 构建一个全是指定 element 的 array
array = np.full((2, 2), 8)
print(array, array.shape) # [[8 8] [8 8]] (2, 2)
# 构建一个对角 array(矩阵)
array = np.eye(3, 3)
print(array) # [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]
# 构建一个随机 element 的 array (数值在 0-1 之间)
array = np.random.random((2, 3))
print(array) # [[0.99736081 0.48195086 0.92102235]
# [0.55686952 0.7174579 0.47941697]]
# 构建一个 element 没有初始化的 array (输出看到的是内存地址)
array = np.empty((2, 2))
print(array) # [[9.90263869e+067 8.01304531e+262]
# [2.60799828e-310 1.42421024e-306]]
# 根据数字范围 构建一维 array
array = np.arange(10)
print(array, array.shape) # [0 1 2 3 4 5 6 7 8 9] (10,)
if __name__ == '__main__':
array_3()
ndarray中元素的不同类型
# -*- coding:utf8 -*-
import numpy as np
def array_dtype():
"""array 中 element 可以有不同的类型"""
# 整形默认是 32位的（长整型是 64位）
li = [1, 2, 3]
array = np.array(li)
print(array.dtype) # int32
# 手动指定元素的数据类型 （不指定则自动匹配合适的类型）
array = np.array(li, dtype=np.int64)
print(array.dtype) # int64
# 将 int64 转换为 float64
float_array = array.astype(np.float)
print(float_array, float_array.dtype) # [1. 2. 3.] float64
# 将 float64 转换为 int32
int_array = array.astype(np.int)
print(int_array, int_array.dtype) # [1 2 3] int32
# 注意： 字符串array可以转成数字array，如果字符串包含字母， 则会转换失败
str_array = np.array(["1.2", "2.3", "aaa"])
float_array = str_array.astype(np.float)
print(float_array) # ValueError: could not convert string to float: 'aaa'
if __name__ == '__main__':
array_dtype()
ndarray取值与赋值
# -*- coding:utf8 -*-
import numpy as np
def array_indexing():
"""array 取值与赋值"""
li = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
array = np.array(li)
print(array.shape) # (3, 4)
# 支持像 list 一样切片（多维数组可以从各个维度同时切片）
a_array = array[0:2, 2:4]
print(a_array) # [[3 4] [7 8]]
# 根据索引赋值
a_array[0, 0] = 999
print(a_array) # [[999 4] [ 7 8]]
print(array) # [[ 1 2 999 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
# 此时，两个 array 都发生了变化，这和 list 的属性是一样的
# 切片是浅拷贝， 只拷贝了最外面的一层
# 用 copy() 函数来进行 深 拷贝
b_array = array[0:2, 2:4].copy()
b_array[0, 1] = 888
print(b_array) # [[999 888] [ 7 8]]
print(array) # [[ 1 2 999 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
# 在多维 array 上取某一行
row_1 = array[1, :] # 取第二行
print(row_1, row_1.shape) # [5 6 7 8] (4,)
# 取某一列
column_1 = array[:, 1] # 取第二列
print(column_1, column_1.shape) # [2 6 10] (3,)
# 根据坐标点取值
print(array[[0, 1, 2], [2, 1, 3]]) # [999 6 12]
# 等同于下面取值方式
print(np.array([array[0, 2], array[1, 1], array[2, 3]])) # [999 6 12]
# 根据坐标点使用 ndarray 取值
print(array[np.arange(3), np.array([2, 1, 3])]) # [999 6 12]
if __name__ == '__main__':
array_indexing()
ndarray基础运算
# -*- coding:utf8 -*-
import numpy as np
def array_operation():
"""array 基础运算"""
x = np.array([[1, 2], [3, 4]])
y = np.array([[5, 6], [7, 8]])
# 多个相同维度 array 逐元素求和, 求差， 求积， 求商
print(np.add(x, y)) # [[ 6 8] [10 12]]
print(x + y) # [[ 6 8] [10 12]]
# 求差
print(y - x) # [[4 4] [4 4]]
print(np.subtract(y, x)) # [[4 4] [4 4]]
# 求积
print(x * y) # [[5 12] [21 32]]
print(np.multiply(x, y)) # [[5 12] [21 32]]
# 求商
print(x / y) # [[0.2 0.33333333]
# [0.42857143 0.5 ]]
print(np.divide(x, y))
# 单个 array 求和
print(np.sum(x)) # 10
# 单个维度求和 (0：纵向求和， 1：横向求和)
print(np.sum(x, axis=0)) # [4 6]
print(np.sum(x, axis=1)) # [3 7]
# 求平方根
print(np.sqrt(x)) # [[1. 1.41421356]
# [1.73205081 2. ]]
# 求 array 内积
m = np.array([9, 10])
n = np.array([10, 11])
print(np.dot(m, n), type(np.dot(m, n))) # 200 <class 'numpy.int32'>
def zhuanzhi():
"""转置（和数学公式一样，简单粗暴）"""
# 一维array转置之后还是自己
x = np.array([1, 2, 3, 4])
print(x.T, x.shape) # [1 2 3 4] (4,)
# 二维 array 的转置
x = np.array([[1, 2, 3, 4]])
print(x.T, x.shape) # [[1]
# [2]
# [3]
# [4]] (1, 4)
# 复杂一点的
x = np.array([[1, 2], [3, 4]])
print(x.T) # [[1 3]
# [2 4]]
if __name__ == '__main__':
array_operation()
zhuanzhi()
ndarray排序
# -*- coding:utf8 -*-
import numpy as np
def array_sort():
"""array 排序"""
# 一维array排序 生成一个元素是 1-9，大小是 10 的array
x = np.random.randint(1, 10, size=10)
print(np.sort(x)) # [1 1 3 4 5 5 5 6 9 9] 默认升序
# 二维array排序 (默认是横向排序)
x = np.random.random((3, 3)) * 10
print(np.sort(x)) # [[0.07488068 1.50793565 8.60498606]
# [0.27312859 3.37282944 9.91854352]
# [1.03615072 2.24717634 6.41866976]]
# 纵向排序 （输出的结果没看懂）
print(np.sort(x, axis=0)) # [[2.24717634 1.03615072 0.07488068]
# [3.37282944 1.50793565 0.27312859]
# [8.60498606 9.91854352 6.41866976]]
if __name__ == '__main__':
array_sort()
ndarray_broadcasting(重点)
不同维度的 array 相互操作
# -*- coding:utf8 -*-
import numpy as np
def array_broadcasting():
"""broadcasting 操作"""
# 不同维度的 array 相加
x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.array([1, 0, 1])
print(x + y) # [[2 2 4]
# [5 5 7]]
# 举一个栗子
x = np.array([1, 2, 3])
y = np.array([4, 5])
# 直接相加是不行的， 换个形状就可以
x = x.reshape(3, 1)
print(x) # [[1]
# [2]
# [3]]
print(x + y) # [[5 6]
# [6 7]
# [7 8]]
#
x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.array([4, 5])
print(x.T + y) # [[ 5 9]
# [ 6 10]
# [ 7 11]]
if __name__ == '__main__':
array_broadcasting()
ndarray逻辑运算
# -*- coding:utf8 -*-
import numpy as np
def logic_operation():
"""array 高级逻辑运算"""
# where() 函数的应用，类似于 三元表达式，True 取x的元素， False取y的元素
x = np.array([1, 2, 3, 4])
y = np.array([5, 6, 7, 8])
bool_array = np.array([True, True, False, False])
print(np.where(bool_array, x, y)) # [1 2 7 8]
# 也可以指定使用条件判断， 结果填充其它的元素
print(np.where(x > 2, 9, -9)) # [-9 -9 9 9]
# 结果也能填充本身
print(np.where(x > 2, 9, x)) # [1 2 9 9]
# bool_array 可以从判断中得到
array = np.random.randint(1, 10, size=(4, 4))
bool_array = array > 5
print(bool_array) # [[False False True False]
# [ True False False True]
# [False True True False]
# [False False True False]]
def array_reshape():
"""改变 array 形状"""
# reshape() 函数的使用， 改变 array 的形状
x = np.random.randint(1, 10, size=15)
print(x.reshape((3, 5))) # [[6 1 8 7 5]
# [5 6 7 8 5]
# [6 3 5 1 9]]
# 更改为已知 array 的 shape
y = np.ones((3, 5))
print(x.reshape(y.shape)) # [[6 1 8 7 5]
# [5 6 7 8 5]
# [6 3 5 1 9]]
def array_ravel():
"""拉平 array"""
x = np.random.randint(1, 10, size=15)
# ravel() 函数的使用， 可以将高维array拉平
print(np.ravel(x), np.ravel(x).shape) # [9 4 7 2 3 9 4 8 2 7 4 7 9 8 6] (15,)
def array_concatenate():
"""拼接 array"""
# concatenate() 函数的应用， 可以将两个 array 拼接起来
x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.array([[7, 8, 9], [10, 11, 12]])
# 模式是 垂直拼接: axis = 0
print(np.concatenate([x, y])) # [[ 1 2 3]
# [ 4 5 6]
# [ 7 8 9]
# [10 11 12]]
# vstack() 函数也能实现垂直拼接， v：vertical 垂直的
print(np.vstack((x, y))) # [[ 1 2 3]
# [ 4 5 6]
# [ 7 8 9]
# [10 11 12]]
# 水平拼接, axis=1
print(np.concatenate([x, y], axis=1)) # [[ 1 2 3 7 8 9]
# [ 4 5 6 10 11 12]]
# hstack() 函数也能实现水平拼接，h：horizontal 水平的
print(np.hstack((x, y))) # [[ 1 2 3 7 8 9]
# [ 4 5 6 10 11 12]]
def array_split():
"""拆分 array"""
x = np.ones((5, 5))
# split() 函数对 array 进行切割, 默认是垂直切割， axis=0
first, second, third = np.split(x, [1, 3])
print(first) # [[1. 1. 1. 1. 1.]]
print(second) # [[1. 1. 1. 1. 1.]
# [1. 1. 1. 1. 1.]]
print(third) # [[1. 1. 1. 1. 1.]
# [1. 1. 1. 1. 1.]]
# 水平切割
first, second, third = np.split(x, [1, 3], axis=1)
print(first) # [[1.]
# [1.]
# [1.]
# [1.]
# [1.]]
print(second) # [[1. 1.]
# [1. 1.]
# [1. 1.]
# [1. 1.]
# [1. 1.]]
print(third) # [[1. 1.]
# [1. 1.]
# [1. 1.]
# [1. 1.]
# [1. 1.]]
def array_repeat():
"""array 操作元素重复"""
x = np.arange(3)
# 按元素全部重复 n 次
print(x.repeat(3)) # [0 0 0 1 1 1 2 2 2]
# 按元素依次重复 1， 2， 3次
print(x.repeat([1, 2, 3])) # [0 1 1 2 2 2]
# 多维array 垂直重复
x = np.arange(8).reshape(2, 4)
print(x.repeat(2, axis=0)) # [[0 1 2 3]
# [0 1 2 3]
# [4 5 6 7]
# [4 5 6 7]]
# 水平重复
print(x.repeat(2, axis=1)) # [[0 0 1 1 2 2 3 3]
# [4 4 5 5 6 6 7 7]]
def array_tile():
"""array 贴瓷砖（整块的重复）"""
x = np.arange(6).reshape((2, 3))
# 重复贴 2 块
print(np.tile(x, 3), "
") # [[0 1 2 0 1 2]
# [3 4 5 3 4 5]]
# 水平方向重复贴 3 块， 垂直方向贴 2 块
print(np.tile(x, (2, 3))) # [[0 1 2 0 1 2 0 1 2]
# [3 4 5 3 4 5 3 4 5]
# [0 1 2 0 1 2 0 1 2]
# [3 4 5 3 4 5 3 4 5]]
if __name__ == '__main__':
logic_operation()
array_repeat()
array_tile()
ndarray的输入与输出（文件）
# -*- coding:utf8 -*-
import numpy as np
def array_to_file():
"""将 array 保存到文件"""
arr = np.loadtxt("csv_file.txt", delimiter=", ")
print(arr, arr.shape)
# 将 array 保存到文件
np.save("some_arr", arr) # 会生成 some_arr.npy 文件
# 打开 .npy 文件
arr_2 = np.load("some_arr.npy")
print(arr_2, arr_2.shape)
# 将多个 array 存储到 file
np.savez("array_archive", arr=arr, arr_2=arr_2)
# 打开 .npz 文件
array_archive = np.load("array_archive.npz") #
print(type(array_archive)) # <class 'numpy.lib.npyio.NpzFile'> 相当于dict
print(type(array_archive["arr"])) # <class 'numpy.ndarray'>
print(array_archive["arr_2"])
if __name__ == '__main__':
array_to_file()
csv_file.txt 文件内容
0.15802498, 0.26676029, 0.67980766, 0.34832594, 0.99836377, 0.6988838
0.33656579, 0.45209998, 0.46830706, 0.12773596, 0.16619608, 0.53966667
0.23431185, 0.18350303, 0.38580821, 0.95580226, 0.43220959, 0.0069545
0.62616423, 0.92959814, 0.35966518, 0.50056307, 0.83907538, 0.91107013
0.75180266, 0.05578861, 0.77242899, 0.47367513, 0.31081774, 0.17424215
0.6344441, 0.26008334, 0.37961022, 0.67820722, 0.36710586, 0.78735928