Numper基础（一）

最新推荐文章于 2024-08-05 17:04:33 发布

AI小白日记

最新推荐文章于 2024-08-05 17:04:33 发布

阅读量1k

点赞数 20

分类专栏： Python基础文章标签： python numpy 开发语言

本文链接：https://blog.csdn.net/zhanghemeng/article/details/140738688

版权

Python基础专栏收录该内容

13 篇文章 0 订阅

订阅专栏

Numper基础（一）

一、本科目标

了解Numpy的应用和特点
掌握Numpy的安装
掌握ndarray的创建和切片操作
掌握ndarray的广播操作
掌握Numpy的各种函数及使用

二、Numpy介绍

Numpy(Numerical Python)是Python语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此处也针对数组运算提供大量的数字函数库
Numpy是一个运行速度非常快的数字库，主要用于数组计算，包含：
- 一个强大的N维数组对象ndarray
- 广播功能函数
- 整合C/C++/Fortran代码的工具
- 线性代数、傅里叶变换、数据数生成等功能

三、NumPy安装

Anaconda：免费Python发行版
使用pip安装
- pip install numpy
测试是否安装成功：
- from numpy import*
- print (eye(4))或者
- import numpy as np
- print(np.eye(4))

四、对象-1

NumPy最重要的一个特点是N维数组对象ndarray，他是一系列同类型数据的集合，以0为下标开始作为元素的索引
- ndarray对象是用于存放同类型元素的多维数组
- ndarray中的每个元素在内存中都有相同存储大小的区域

五、对象-2

创建一个 ndarray 只需调用 NumPy 的 array 函数即可：

import numpy as np
a = np.array([1, 2, 3])
print(a)
a = np.array([[1, 2], [3, 4]]) # 多一个维度
print(a)
a = np.array([1, 2, 3, 4, 5], ndmin = 2)  # 最小维度
print(a)
a = np.array([1, 2, 3], dtype = int)  # dtype参数
print(a)
'''
[1 2 3]
[[1 2]
 [3 4]]
[[1 2 3 4 5]]
[1 2 3]
'''

六、数组属性

数组的维数称为(rank)，即数组的维度
- 一维数组的秩为1，二维数组的秩为2，以此类推
每一个线性的数组称为是一个轴(axis)
- axis = 0，表示沿着第0轴进行操作，即对每一列进行操作
- axis = 1，表示沿着第1轴进行操作，即对每一列进行操作

七、比较重要ndarray对象属性

属性	说明
ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵， n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型

a = np.arange(24)
print(a)
print(a.ndim)
print("*"*20)
b = a.reshape(2, 4, 3)
print(b)
print(b.ndim)
print(b.shape)
print("*"*20)
a = np.array([[1, 2, 3],[4, 5, 6]])
print(a)
print(a.shape)
print("*"*20)
a.shape = (3, 2)
print(a)
print("*"*20)
b = a.reshape(2, 3)
print(b)
'''
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
1
********************
[[[ 0  1  2]
  [ 3  4  5]
  [ 6  7  8]
  [ 9 10 11]]

 [[12 13 14]
  [15 16 17]
  [18 19 20]
  [21 22 23]]]
3
(2, 4, 3)
********************
[[1 2 3]
 [4 5 6]]
(2, 3)
********************
[[1 2]
 [3 4]
 [5 6]]
********************
[[1 2 3]
 [4 5 6]]
'''

八、创建数组的其他方式

numpy.empty
- 创建一个指定形状、数据类型且随机值的数组

x = np.empty(5, dtype = int)
y = np. empty([3, 2], dtype = int)
print(x)
print(y)
'''
[3634967849244717568        220955934720 6874570461487763674
 7521983764486121828 4211428601560461925]
[[0 0]
 [0 0]
 [0 0]]
'''

numpy.zeros
- 创建指定大小的数组，数组元素以0来填充：

x = np.zeros(5)
y = np.zeros((5,), dtype = int)
print(x)
print(y)
'''
[0. 0. 0. 0. 0.]
[0 0 0 0 0]
'''

numpy.ones
- 创建指定形状的数组，数组元素以1来填充：

x = np.ones(5)
y = np.ones([2, 2], dtype = int)
print(x)
print(y)
'''
[1. 1. 1. 1. 1.]
[[1 1]
 [1 1]]
'''

九、从已有的数组创建数组

numpy.asarray

x = [1, 2, 3]
a = np.asarray(x)
print(a)
print("*"*20)
x = (1, 2, 3)
a = np.asarray(x)
print(a)
print("*"*20)
x = [(1, 2, 3), (4, 5, 6)]
a = np.asarray(x)
print(a)
print("*"*20)
x = [1, 2 , 3]
a = np.asarray(x, dtype = float)
print(a)
print("*"*20)
'''
[1 2 3]
********************
[1 2 3]
********************
[[1 2 3]
 [4 5 6]]
********************
[1. 2. 3.]
********************
'''

十、从数值范围创建数组

numpy.arange

x = np.arange(5)
print(x)
x = np.arange(5, dtype = float)
print(x)
x = np.arange(10, 20, 2)
print(x)
'''
[0 1 2 3 4]
[0. 1. 2. 3. 4.]
[10 12 14 16 18]
'''

十一、切片和索引

与python中list的切片操作一样
切片对象可以通过内置的slice函数

a = np.arange(10)
print(a)
s = slice(2, 7, 2)
print(a[s])
a = np.arange(10)
b = a[2:7:2]
print(b)
a = np. arange(10)
b = a[5]
print(b)
'''
[0 1 2 3 4 5 6 7 8 9]
[2 4 6]
[2 4 6]
5
'''

a = np.arange(10)
print(a[2:])
print(a[2:5])
print("*"*20)
a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
print(a)
print(a[1:])
'''
[2 3 4 5 6 7 8 9]
[2 3 4]
********************
[[1 2 3]
 [3 4 5]
 [4 5 6]]
[[3 4 5]
 [4 5 6]]
'''

a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
print(a)
print("*"*20)
print(a[..., 1])#第二列的元素
print("*"*20)
print(a[1, ...])#第二行的元素
print("*"*20)
print(a[..., 1:])#第二行及剩下的所有元素
'''
[[1 2 3]
 [3 4 5]
 [4 5 6]]
********************
[2 4 5]
********************
[3 4 5]
********************
[[2 3]
 [4 5]
 [5 6]]
'''

十二、广播(Broadcast)

广播(Broadcast)是numpy对不同形状（shape)的数组进行数值计算的方式，对数组的运算通常在相应的元素上进行
如果两个数组a和b形状相同，即满足a.shape == b.shape，那么a*b的结果就是a与b数组对应位相乘。这要求维数相同，且各维度的长度相同

a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])
c = a * b
print(c)
print("*"*20)
a = np.array([[0, 0, 0], [10, 10, 10], [20, 20, 20], [30, 30, 30]])
b = np.array([0, 1, 2])
c = a + b
print(c)
'''
[ 10  40  90 160]
********************
[[ 0  1  2]
 [10 11 12]
 [20 21 22]
 [30 31 32]]
'''

十三、广播的规则

规则一：如果两个数组在维度上不匹配，那么数组的形状会沿着长度为1的维度进行扩展以匹配另一个数组的形状
规则二：如果两个数组在任何维度上的大小不一致，并且其中一个数组在该维度上的大小为1，则这个数组看起来会被复制扩展到与另一个数组相同的大小
规则三：如果在所有维度上大小都不匹配，并且没有任何一个维度等于1，则会发生错误

十四、数组操作

Numpy中包含了一些函数用于处理数组，大概可分为以下几类：
- 修改数组形状
- 翻转数组
- 修改数组维度
- 连接数组
- 分隔数组
- 数组元素的添加与删除

十五、修改数组形状

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

a = np.arange(8)
print('原始数组：')
print(a)
print('\n')
b = a.reshape(4, 2)
print('修改后的数组：')
print(b)
'''
原始数组：
[0 1 2 3 4 5 6 7]
修改后的数组：
[[0 1]
 [2 3]
 [4 5]
 [6 7]]
'''

a = np.arange(9).reshape(3, 3)
print('原始数组：')
print(a)
print("*"*20)
for row in a:
    print(row)
# 对数组中每个元素都进行处理，可以使用flat属性是一个数组元素迭代器：
print('迭代后的数组：')
for element in a.flat:
    print(element)
'''
原始数组：
[[0 1 2]
 [3 4 5]
 [6 7 8]]
********************
[0 1 2]
[3 4 5]
[6 7 8]
迭代后的数组：
0
1
2
3
4
5
6
7
8
'''

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]
'''

a = np.arange(8).reshape(2, 4)
print('原数组：')
print(a)
print('\n')
print('调用ravel函数之后：')
print(a.ravel())
print('\n')
print('以F风格顺序调用ravel函数之后：')
print(a.ravel(order = 'F'))
'''
原数组：
[[0 1 2 3]
 [4 5 6 7]]
调用ravel函数之后：
[0 1 2 3 4 5 6 7]
以F风格顺序调用ravel函数之后：
[0 4 1 5 2 6 3 7]
'''

十六、翻转数组

函数述	描述
transpose	对换数组的维度
ndarray.T	和 self.transpose() 相同

a = np.arange(12).reshape(3, 4)
print('原数组：')
print(a)
print('\n')
print('对换数组：')
print(np.transpose(a))
'''
原数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
对换数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]
'''

a = np.arange(12).reshape(3, 4)
print('原数组：')
print(a)
print('\n')
print('转置数组：')
print(a.T)
'''
原数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
转置数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]
'''

十七、连接数组

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

a = np.array([[1, 2], [3, 4]])
print('第一个数组：')
print(a)
b = np.array([[5, 6], [7, 8]])
print('第二个数组是：')
print(b)
print('沿轴0连接两个数组：')
print(np.concatenate((a, b)))
print('沿轴1连接两个数组：')
print(np.concatenate((a, b), axis = 1))
'''
第一个数组：
[[1 2]
 [3 4]]
第二个数组是：
[[5 6]
 [7 8]]
沿轴0连接两个数组：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
沿轴1连接两个数组：
[[1 2 5 6]
 [3 4 7 8]]
'''

a = np.array([[1, 2], [3, 4]])
print('第一个数组：')
print(a)
b = np.array([[5, 6], [7, 8]])
print('第二个数组：')
print(b)
print('沿轴0堆叠两个数组：')
print(np.stack((a, b), 0))
print('沿1轴堆叠两个数组：')
print(np.stack((a, b), 1))
'''
第一个数组：
[[1 2]
 [3 4]]
第二个数组：
[[5 6]
 [7 8]]
沿轴0堆叠两个数组：
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]
沿1轴堆叠两个数组：
[[[1 2]
  [5 6]]
  
 [[3 4]
  [7 8]]]
'''

a = np.array([[1, 2], [3, 4]])
print('第一个数组：')
print(a)
b = np.array([[5, 6], [7, 8]])
print('第二个数组：')
print(b)
print('水平堆叠：')
c = np.hstack((a, b))
print(c)
print('竖直堆叠：')
c = np.vstack((a, b))
print(c)
'''
第一个数组：
[[1 2]
 [3 4]]
第二个数组：
[[5 6]
 [7 8]]
水平堆叠：
[[1 2 5 6]
 [3 4 7 8]]
竖直堆叠：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
'''

十八、分隔数组

函数	数组及操作
split	将一个数组分割为多个子数组
hsplit	将一个数组水平分割为多个子数组（按列）
vsplit	将一个数组垂直分割为多个子数组（按行）

a = np.arange(9)
print('第一个数组：')
print(a)
print('将数组分为三个大小相等的子数组：')
b = np.split(a, 3)
print(b)
print('将数组在一维数组中表明的位置分割：')
b = np.split(a, [4, 7])
print(b)
'''
第一个数组：
[0 1 2 3 4 5 6 7 8]
将数组分为三个大小相等的子数组：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
将数组在一维数组中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])
'''

a = np.arange(16).reshape(4, 4)
print('第一个数组：')
print(a)
print('默认分割（0轴）：')
b = np.split(a, 2)
print(b)
print('沿水平方向分割：')
c = np.split(a, 2, 1)
print(c)
print('沿水平方向分割：')
d = np.hsplit(a, 2)
print(d)
'''
第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
默认分割（0轴）：
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]
沿水平方向分割：
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]
沿水平方向分割：
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]
'''

#生成一个2行6列的数组，数组中的每个元素是一个0到10之间的随机浮点数，并取其下舍整数结果，然后将这个处理后的数组赋值给变量harr
harr = np.floor(10 * np.random.random((2, 6)))
print('原array:')
print(harr)
print('拆分后：')
print(np.hsplit(harr, 3))
'''
原array:
[[7. 3. 1. 7. 6. 1.]
 [9. 8. 2. 5. 1. 6.]]
拆分后：
[array([[7., 3.],
       [9., 8.]]), array([[1., 7.],
       [2., 5.]]), array([[6., 1.],
       [1., 6.]])]
'''

a = np.arange(16).reshape(4, 4)
print('第一个数组：')
print(a)
print('\n')
print('竖直分隔：')
b = np.vsplit(a, 2)
print(b)
'''
第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
竖直分隔：
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]
'''

十九、总结

了解Numpy的应用和特点
掌握Numpy的安装
掌握ndarray的创建和属性
掌握ndarray的索引和切片的操作
掌握ndarray的广播操作
掌握Numpy的各种函数及使用

AI小白日记

关注

20
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
0
评论
Numper基础（一）

- 了解Numpy的应用和特点- 掌握Numpy的安装- 掌握ndarray的创建和属性- 掌握ndarray的索引和切片的操作- 掌握ndarray的广播操作- 掌握Numpy的各种函数及使用
复制链接

扫一扫