21天Python进阶学习挑战赛打卡3

intfen

于 2022-08-06 20:33:25 发布

阅读量208

点赞数

文章标签： python 开发语言学习

本文链接：https://blog.csdn.net/intfen/article/details/126199750

版权

活动地址：CSDN21天学习挑战赛

学习日记

1，学习知识点

numpy模块

2，学习遇到的问题

初次学习，不太熟练

3，学习的收获

NumPy 是 Python 语言的一个第三方库，其支持大量高维度数组与矩阵运算。此外，NumPy 也针对数组运算提供大量的数学函数。机器学习涉及到大量对数组的变换和运算，NumPy 就成了必不可少的工具之一。

作用：NumPy是一个运行速度非常快的数学库，主要用于数组计算

包含：

一个强大的N维数组对象ndarray

广播功能函数

线性代数、傅里叶变换、随机数生成等功能

优势：

对于同样的数值计算任务，使用numpy要比直接编写Python代码便捷的多
numpy中的数组的存储效率和输入输出性能均远远优于Python中等价的基本数据结构，且其能够提升性能是与数组中的元素成比例的
numpy的大部分代码都是用C语言写的，其底层算法在设计时就有着优异的性能，这使得numpy比纯Python代码高效得多

ndarray对象：

NumPy定义了一个n维数组对象，简称ndarray对象，它是一个一系列相同类型元素组成的数组集合。数组中的每个元素都占有大小相同的内存块

ndarray对象采用了数组的索引机制，将数组中的每个元素映射到内存块上，并且按照一定的布局对内存块进行排列(行或列)。

4，实操

安装numpy，输入对应的pip命令：pip install numpy

导包：
import numpy as np

numpy模块的基本使用

1. numpy数据类型

numpy支持的数据类型比Python内置的类型要多很多，基本上可以和C语言的数据类型对应上，其中部分类型对应为Python内置的类型

numpy的数值类型实际上是dtype对象的实例，并对应唯一-的字符，包括np.bool_ ,np.int32，np.float32, 等等

类型	类型代码	说明
int8、uint8	i1、u1	有符号和无符号的8位(1个字节) 整型
int16, uint16	i2、u2	有符号和无符号的16位(2个字节) 整型
int32、uint32	i4、u4	有符号和无符号的32位(4个字节) 整型
int64、uint64	i8、u8	有符号和无符号的64位(8个字节) 整型
float16	f2	半精度浮点数
float32	f4或者f	标准的单精度浮点数。与C的float兼容
float64	f8或d	标准的双精度浮点数。与C的double 和Python的float对象兼容
float1 28	f16或g	扩展精度浮点数
complex64. complex128.	c8、c16	分别用两个32位、64位或128位浮点数表示的
complex256	c32	复数
bool	b	存储True和False值的布尔类型

数据类型对象是用来描述与数组对应的内存区域如何使用，这依赖如下几个方面:

数据的类型(整数，浮点数或者Python对象)
数据的大小(例如，整数使用多少个字节存储)
数据的字节顺序(小端法或大端法) [通过对数据类型预先设定"<“或”>"来决定的。<“意味着小端法(最小值存储在最小的地址，即低位组放在最前面)。”>"意味着大端法(最重要的字节存储在最小的地址，即高位组放在最前面)]
在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的
部分
如果数据类型是子数组，它的形状和数据类型

创建数据类型对象语法：numpy.dtype(object, align, copy)

参数说明：

object：要转换为的数据类型对象
align：如果为true,填充字段使其类似C的结构体
copy：复制dtype对象，如果为false,则是对内置数据类型对象的引用.

基本使用：

>>> import numpy as np
>>> dt = np.dtype(np.int32)
>>> print(dt)
int32
>>> print(type(dt))
<class 'numpy.dtype[int32]'>

# 数据类型缩写
>>> dt1 = np.dtype('i1')
>>> print(dt1)
int8
>>> print(type(dt1))
<class 'numpy.dtype[int8]'>

2. 创建数组

语法格式：numpy.array(object, dtype = None, copy = True, order = None,subok=False,ndmin = 0)

参数说明：

object：表示一个数组序列。
dtype ：可选参数，通过它可以更改数组的数据类型
copy：可选参数，当数据源是ndarray时表示数组能否被复制，默认是True。
order：可选参数，以哪种内存布局创建数组，有3个可选值，分别是C(行序列)/F(列序列)/A(默认)。
ndmin：可选参数，用于指定数组的维度。
subok：可选参数，类型为boo值，默认False。为True, 使用object的内部数据类型; False: 使用object数组的数据类型。

>>> import numpy as np
# 列表
>>> t1 = np.array([1,2,3])
>>> print(t1)
[1 2 3]
# 迭代对象
>>> t2 = np.array(range(10))
>>> print(t2)
[0 1 2 3 4 5 6 7 8 9]
>>> print(type(t2))
<class 'numpy.ndarray'>

>>> t3 = np.arange(10)
>>> print(t3)
[0 1 2 3 4 5 6 7 8 9]
>>> print(type(t3))
<class 'numpy.ndarray'>

>>> t4 = np.arange(2,10,2)
>>> print(t4)
[2 4 6 8]
>>> print(type(t4))
<class 'numpy.ndarray'>

注意：arange和range的区别

>>> a = np.array([1,2,3,4,5])
>>> a.dtype
dtype('int32')

3. Ndarray数组属性

NumPy数组的维数称为秩(rank)，一维数组的秩为1，二维数组的秩为2，以此类推

在NumPy中，每一个线性的数组称为是一个轴(axis) ，也就是维度(dimensions) 。比如说，二维数组相当于是两个- -维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是NumPy中的轴(axis) ，第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量一一秩，就是数组的维数

很多时候可以声明axis。axis=O, 表示沿着第0轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作

常用属性：

属性	说明
ndim	秩，即轴的数量或维度的数量
shape	数组的维度，对于矩阵，n行m列
size	数组元素的总个数，相当于.shape中n*m的值
dtype	ndarray对象的元素类型
itemsize	ndarray对象中每个元素的大小，以字节为单位
flags	ndarray对象的内存信息
real	ndarray元素的实部
imag	ndarray元素的虚部
data	包含实际数组元素的缓冲区，由于-般通过数组的索引获取元素，所以通常不需要使用这个属性

1. ndim ：

>>> import numpy as np
>>> arr = np.arange(24)
>>> print(arr)
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
>>> print(arr.ndim)
1

# 调整维度，li 为三维
>>> li = arr.reshape(2,3,4)
>>> print(li)
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
>>> print(li.ndim)
3

2. shape：表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即ndim属性(秩)。比
如，一个二维数组，其维度表示"行数"和"列数"：

获取维度

>>> import numpy as np
>>> arr = np.array([[1,2,3],[4,5,6]])
>>> print(arr)
[[1 2 3]
 [4 5 6]]
>>> print(arr.shape)
(2, 3)

调整维度

>>> arr.shape = (3,2)
>>> print(arr)
[[1 2]
 [3 4]
 [5 6]]
>>> print(arr.shape)
(3, 2)

3. 其他属性：

>>> import numpy as np
>>> arr = np.array([[1,2,3],[4,5,6]])
>>> print(arr.size)
6
>>> print(arr.dtype)
int32
>>> print(arr.itemsize)
4
>>> print(arr.flags)
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

三、元素操作

1. 索引和切片

ndarray对象的内容可以通过索引或切片来访问和修改，与Python中list的切片操作一样

ndarray数组可以基于0-n的下标进行索引，切片对象可以通过内置的slice函数，并设置start, stop及step参数进行, (从原数组中切割出一个新数组

>>> t = np.arange(0,20).reshape(5,4)
>>> t
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19]])
>>> # 取行
>>> t[0]
array([0, 1, 2, 3])
>>> # 取连续多行
>>> t[:2]
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])
>>> t[2:]
array([[ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19]])
>>> # 取不连续的多行
>>> t[[2,4]]
array([[ 8,  9, 10, 11],
       [16, 17, 18, 19]])
>>> # 取列
>>> t[:,0]
array([ 0,  4,  8, 12, 16])
>>> # 取连续的多列
>>> t[:,:2]
array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13],
       [16, 17]])
>>> t[:,2:]
array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15],
       [18, 19]])
>>> # 取不连续多列
>>> t[:,[0,2]]
array([[ 0,  2],
       [ 4,  6],
       [ 8, 10],
       [12, 14],
       [16, 18]])
>>> # 取行列（第3行，第4列）
>>> t[2,3]
11
>>> # 取多行多列（第3-5行，第2-4列）
>>> t[2:5,1:4]
array([[ 9, 10, 11],
       [13, 14, 15],
       [17, 18, 19]])
>>> # 取多个不相邻的点（0,0）（2,1）
>>> t[[0,2],[0,1]]
array([0, 9])

2. 布尔索引

布尔索引通过布尔运算(如:比较运算符)来获取符合指定条件的元素的数组。

>>> t = np.arange(0,20).reshape(5,4)
>>> t
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19]])
# 布尔索引
>>> t<10
array([[ True,  True,  True,  True],
       [ True,  True,  True,  True],
       [ True,  True, False, False],
       [False, False, False, False],
       [False, False, False, False]])
>>> # 取数组中大于10的值
>>> t[t>10]
array([11, 12, 13, 14, 15, 16, 17, 18, 19])
>>> # 取数组中小于10的值
>>> t[t<10]
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

3. 广播原则

numpy对不同形状(shape)的数组进行数值计算的方式，对数组的算术运算通常在相应的元素上进行。

形状相同：如果两个数组a和b形状相同，即满足a.shape == b.shape，那么a+b的结果就是a与b数组对应位相加。这要求维数相同，且各维度的长度相同

>>> import numpy as np
>>> a = np.array([1,2,3,4])
>>> b = np.array([5,6,7,8])
>>> c = a + b
>>> print(c)
[ 6  8 10 12]

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

>>> a = np.array([[0,0],[1,1],[2,2]])
>>> b = np.array([3,3])
>>> print(a+b)
[[3 3]
 [4 4]
 [5 5]]

广播的规则：

让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加1补
齐
输出数组的形状是输入数组形状的各个维度上的最大值
如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为1时，这个数
组能够用来计算，否则出错
当输入数组的某个维度的长度为1时，沿着此维度运算时都用此维度上的第-组值

4. 轴(axis)

在numpy中可以理解为方向，使用0,1,2…数字表示,对于一个一维数组，只有一个0轴，对于2维数(shape(2,2))，有0轴和1轴，对于三维数组(shape(2,2,3))，有0,1,2轴

有了轴的概念之后,我们计算会更加方便,比如计算一个2维数组的平均值,必须指定是计算哪个方向上面的数字的平均值

明白了轴的概念之后,对于shape返回的结果和reshape的结果能够更加清楚。