工具及其软件基础

达芬奇的奇妙之旅

已于 2023-04-20 17:29:29 修改

阅读量529

点赞数

于 2023-04-18 15:54:40 首次发布

本文链接：https://blog.csdn.net/m0_49218627/article/details/130223948

版权

机器学习专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.numpy

NumPy是Python中常用的科学计算库，提供了高效的数组操作和数值运算工具。它的核心是一个多维数组对象 ndarray，它支持基于数组的操作，如数学、逻辑、数组的形状操作等。同时，NumPy中还提供了许多用于数据处理和操作的工具，例如线性代数、随机数生成、傅里叶变换等等。

NumPy的一个重要优势是其运算速度和效率。NumPy中所有的数值操作都是在多维数组上进行的，这些操作都是基于C语言的，因此具有非常高的性能。此外，NumPy还与许多其他科学计算工具和可视化库进行了整合，如SciPy、Matplotlib、Pandas等等，这使得NumPy成为Python科学计算生态的一个重要组成部分。总之，NumPy是一个重要的Python库，提供了高效的数组操作和数值计算工具，为数据科学和计算科学提供了强大的支持。

安装

pip install numpy

出现

Requirement already satisfied: numpy in d:\pycharmproject\venv\lib\site-packages (1.24.2)

表示安装成功

随便写个代码检测一下：

import numpy as np

a=np.arange(10)
print(a)

输出0-9表示成功了

array创建数组

array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, like=None) Create an array.

//控制台操作
PyDev console: starting.
Python 3.11.3 (tags/v3.11.3:f3909b8, Apr  4 2023, 23:49:59) [MSC v.1934 64 bit (AMD64)] on win32
import numpy as np
np.array([10,20,30,40,50])
array([10, 20, 30, 40, 50])
np.array([[10,20,30],[10,10,10],[20,12,12]])
array([[10, 20, 30],
       [10, 10, 10],
       [20, 12, 12]])
np.array([[[10,10,10],[20,20,20],[30,30,30]]])
array([[[10, 10, 10],
        [20, 20, 20],
        [30, 30, 30]]])

dtype可以制定元素类型

np.array([10,20,30,40],dtype=float)
array([10., 20., 30., 40.])

使用zeros或ones函数创建指定大小的全零或全一数组

arange创建数组

np.arange(20)
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19])
np.arange(1,21)
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
       18, 19, 20])
np.arange(1,100,20)
array([ 1, 21, 41, 61, 81])

加上dtype

np.arange(1,21,dtype=np.float_)
array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12., 13.,
       14., 15., 16., 17., 18., 19., 20.])

创建二维数组

np.array([np.arange(1,4),np.arange(4,7)])
array([[1, 2, 3],
       [4, 5, 6]])

随机数创建数组

#确定随机数种子
np.random.seed(0)
np.random.random()
0.5488135039273248
a=np.random.random(size=5)
print(a)
[0.71518937 0.60276338 0.54488318 0.4236548  0.64589411]
print(a.shape)
(5,)
aa=np.random.random(size=(4,5))
print(aa)
[[0.43758721 0.891773   0.96366276 0.38344152 0.79172504]
 [0.52889492 0.56804456 0.92559664 0.07103606 0.0871293 ]
 [0.0202184  0.83261985 0.77815675 0.87001215 0.97861834]
 [0.79915856 0.46147936 0.78052918 0.11827443 0.63992102]]
aaa=np.random.random(size=(2,3,4))
print(aaa)
[[[0.14335329 0.94466892 0.52184832 0.41466194]
  [0.26455561 0.77423369 0.45615033 0.56843395]
  [0.0187898  0.6176355  0.61209572 0.616934  ]]
 [[0.94374808 0.6818203  0.3595079  0.43703195]
  [0.6976312  0.06022547 0.66676672 0.67063787]
  [0.21038256 0.1289263  0.31542835 0.36371077]]]
#随机整数
np.random.randint(5)
1
np.random.randint(1,11,size=20)
array([ 5,  5,  7,  5,  5,  4,  5,  5,  9,  5,  4,  8,  6,  6,  1,  2,  6,
       10,  4,  1])

#正态分布
np.random.randn(2,3,4)
array([[[ 1.50944508,  1.06777513, -0.68658948,  0.01487332],
        [-0.3756659 , -0.03822364,  0.36797447, -0.0447237 ],
        [-0.30237513, -2.2244036 ,  0.72400636,  0.35900276]],
       [[ 1.07612104,  0.19214083,  0.85292596,  0.01835718],
        [ 0.42830357,  0.99627783, -0.49114966,  0.71267817],
        [ 1.11334035, -2.15367459, -0.41611148, -1.07089699]]])
np.random.normal(loc=3,scale=1,size=4)
array([3.22113881, 1.87694288, 1.94924204, 4.01207905])

ndarray

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

ndarray 对象是用于存放同类型元素的多维数组。

ndarray 中的每个元素在内存中都有相同存储大小的区域。

ndarray 内部由以下内容组成：

一个指向数据（内存或内存映射文件中的一块数据）的指针。
数据类型或 dtype，描述在数组中的固定大小值的格子。
一个表示数组形状（shape）的元组，表示各维度大小的元组。
一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。

a=np.array([1,2,3])
print(a)
[1 2 3]
#多一个维度
a=np.array([1,2,3],dtype=complex)
print(a)
[1.+0.j 2.+0.j 3.+0.j]

dtype类型对象

在NumPy中，dtype是numpy中一个重要的对象，用来描述ndarray数组的数据类型。每个ndarray数组都有一个dtype对象，该对象定义了数组中元素的数据类型，如float、int、bool、complex等等。 NumPy中常见的数据类型包括：

int：整数类型，可以使用int8、int16、int32、int64等不同的位数表示不同的范围。
float:浮点类型，可以使用float16、float32、float64等不同的位数表示不同的精度。
bool:布尔类型，只能储存True或False。
complex:复数类型，可以使用complex64、complex128等不同的位数表示不同的精度。
string_:字符串类型，可以使用string_类型定义一个固定长度的字符串。使用dtype来指定ndarray数组的数据类型，可以通过在array函数中添加dtype参数来实现。

dtype 对象是使用以下语法构造的：

numpy.dtype(object, align, copy)

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

student=np.dtype([('name','S20'),('age','i1'),('marks','f4')])
a=np.array([('abc',21,50),('xyz',18,75)],dtype=student)
print(a)
[(b'abc', 21, 50.) (b'xyz', 18, 75.)]

dt=np.dtype(np.int32)
print(dt)
int32
#int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
dt=np.dtype('i4')
print(dt)
int32
#创建结构化数据类型
dt=np.dtype([('age',np.int8)])
print(dt)
[('age', 'i1')]
#将数据类型应用余ndarray对象
a=np.array([(10,),(20,),(30,)],dtype=dt)
print(a)
[(10,) (20,) (30,)]

numpy创建数组

ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建。

numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

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

x=np.empty([3,3],dtype=int)
print(x)
[[1527424112        706 1527509808]
 [       706 1969621466 1869898606]
 [1920167023         81 1936024425]]

numpy.zeros

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

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

x=np.zeros(5)
print
<built-in function print>
print(x)
[0. 0. 0. 0. 0.]
#整型
y=np.zeros((5,),dtype=int)
print(y)
[0 0 0 0 0]

numpy.zeros_like

numpy.zeros_like 用于创建一个与给定数组具有相同形状的数组，数组元素以 0 来填充。

numpy.zeros 和 numpy.zeros_like 都是用于创建一个指定形状的数组，其中所有元素都是 0。

它们之间的区别在于：numpy.zeros 可以直接指定要创建的数组的形状，而 numpy.zeros_like 则是创建一个与给定数组具有相同形状的数组。

numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)

#创建一个和arr形状相同的所有元素均为0的数组
zeros_arr=np.zeros_like(arr)
print(zeros_arr)
[[0 0 0]
 [0 0 0]
 [0 0 0]]

从已有数组中创建数组

numpy.asarray

numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个。

numpy.asarray(a, dtype = None, order = None)

x=[1,2,3]
a=np.asarray(x,dtype=float)
print(a)
[1. 2. 3.]

numpy.frombuffer

numpy.frombuffer 用于实现动态数组。

numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

import numpy as np
s =  'Hello World'
a = np.frombuffer(s, dtype =  'S1')
print (a)

numpy.fromiter

numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。

numpy.fromiter(iterable, dtype, count=-1)

list=range(5)
print(list)
range(0, 5)
it=iter(list)
#使用迭代器创建按ndarray
x=np.fromiter(it,dtype=float)
print(x)
[0. 1. 2. 3. 4.]

从数值范围创建数组

numpy.arange

numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：

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

根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

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

numpy.linspace

numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

a=np.linspace(1,10,10)
print(a)
[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
#将 endpoint 设为 false，不包含终止值：
a=np.linspace(10,20,5,endpoint=False)
print(a)
[10. 12. 14. 16. 18.]
#设置间距
a=np.linspace(1,10,10,retstep=True)
print(a)
(array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0)
b=np.linspace(1,10,10).reshape([10,1])
print(b)
[[ 1.]
 [ 2.]
 [ 3.]
 [ 4.]
 [ 5.]
 [ 6.]
 [ 7.]
 [ 8.]
 [ 9.]
 [10.]]

numpy.logspace

numpy.logspace 函数用于创建一个于等比数列。格式如下：

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

a=np.logspace(1.0,2.0,num=10)
print(a)
[ 10.          12.91549665  16.68100537  21.5443469   27.82559402
  35.93813664  46.41588834  59.94842503  77.42636827 100.        ]
#将底数设置为2
a=np.logspace(0,9,10,base=2)
print(a)
[  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]

切片和索引

a=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(a)
[[1 2 3]
 [4 5 6]
 [7 8 9]]
print(a[1:])
[[4 5 6]
 [7 8 9]]
#切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。
print(a[...,1])#第二列
[2 5 8]
print(a[1,...])#第二行
[4 5 6]
print(a[...,1:])#第二列及其剩下元素
[[2 3]
 [5 6]
 [8 9]]

高级索引

整数数组索引

整数数组索引是指使用一个数组来访问另一个数组的元素。这个数组中的每个元素都是目标数组中某个维度上的索引值。

以下实例获取数组中 (0,0)，(1,1) 和 (2,0) 位置处的元素。
x=np.array([[1,2],[3,4],[5,6]])
y=x[[0,1,2],[0,1,0]]
print(y)
[1 4 5]

x=np.array([[1,2],[3,4],[5,6]])
y=x[[0,1,2],[0,1,0]]
print(y)
[1 4 5]
a=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(a)
[[1 2 3]
 [4 5 6]
 [7 8 9]]
b=a[1:3,1:3]
print(b)
[[5 6]
 [8 9]]
c=a[1:3,[1,2]]
print(c)
[[5 6]
 [8 9]]

布尔索引

我们可以通过一个布尔数组来索引目标数组。

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

以下实例获取大于 5 的元素：

x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print(x)
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
print  ('大于 5 的元素是：')
print (x[x >  5])
大于 5 的元素是：
[ 6  7  8  9 10 11]
#以下实例演示如何从数组中过滤掉非复数元素。
a=np.array([1,2+6j,5,3.5+5j])
print(a[np.iscomplex(a)])
[2. +6.j 3.5+5.j]

花式索引

花式索引指的是利用整数数组进行索引。

花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。

对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素，如果目标是二维数组，那么就是对应下标的行。

花式索引跟切片不一样，它总是将数据复制到新数组中。

x2=x[[0,6]]
print(x2)
[0 6]
print(x2[0])
0
print(x2[1])
6
x=np.arange(32).reshape((8,4))
print(x)
[[ 0  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]]
print(x[[4,2,1,7]])
[[16 17 18 19]
 [ 8  9 10 11]
 [ 4  5  6  7]
 [28 29 30 31]]

数组操作

numpy.reshape

numpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下：

numpy.reshape(arr, newshape, order='C')

arr：要修改形状的数组
newshape：整数或者整数数组，新的形状应当兼容原有形状
order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序。

a=np.arange(8)
print(a)
[0 1 2 3 4 5 6 7]
b=a.reshape(4,2)
print(b)
[[0 1]
 [2 3]
 [4 5]
 [6 7]]

numpy.ndarray.flat

numpy.ndarray.flat 是一个数组元素迭代器，实例如下:

a=np.arange(8).reshape(4,2)
print(a)
[[0 1]
 [2 3]
 [4 5]
 [6 7]]
for row in a:
    print(row)#类似于迭代器
    
[0 1]
[2 3]
[4 5]
[6 7]
for element in a.flat:
    print(element)
    
0
1
2
3
4
5
6
7

numpy.ndarray.flatten

numpy.ndarray.flatten 返回一份数组拷贝

print(a)
[[0 1]
 [2 3]
 [4 5]
 [6 7]]
print(a.flatten())
[0 1 2 3 4 5 6 7]
print(a.flatten(order='F'))
[0 2 4 6 1 3 5 7]
print(a.flatten(order='C'))
[0 1 2 3 4 5 6 7]
print(a.flatten(order='A'))
[0 1 2 3 4 5 6 7]
print(a.flatten(order='K'))
[0 1 2 3 4 5 6 7]

order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。

numpy.ravel

numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。

print(a)
[[0 1]
 [2 3]
 [4 5]
 [6 7]]
print(a.ravel())
[0 1 2 3 4 5 6 7]
print(a.ravel('F'))
[0 2 4 6 1 3 5 7]

翻转数组

numpy.transpose

numpy.transpose 函数用于对换数组的维度，格式如下：

numpy.transpose(arr, axes)

print(a)
[[0 1]
 [2 3]
 [4 5]
 [6 7]]
print(np.transpose(a))
[[0 2 4 6]
 [1 3 5 7]]
print(a.T)
[[0 2 4 6]
 [1 3 5 7]]

numpy.rollaxis

numpy.rollaxis 函数向后滚动特定的轴到一个特定位置，格式如下：

numpy.rollaxis(arr, axis, start)

a=np.arange(8).reshape(2,2,2)
print(a)
[[[0 1]
  [2 3]]
 [[4 5]
  [6 7]]]
b=np.rollaxis(a,2,0)
print(b)
[[[0 2]
  [4 6]]
 [[1 3]
  [5 7]]]

字符串函数

numpy.char.add()

numpy.char.add() 函数依次对两个数组的元素进行字符串连接。

print(np.char.add(['hello'],['xyz']))
['helloxyz']
print(np.char.add(['hello','hi'],['abc','xyz']))
['helloabc' 'hixyz']

numpy.char.multiply()

numpy.char.multiply() 函数执行多重连接。

print(np.char.multiply('hhh',3))
hhhhhhhhh

numpy.char.center()

numpy.char.center() 函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充。

print(np.char.center('run',20,fillchar='*'))
********run*********

numpy.char.capitalize()

numpy.char.capitalize() 函数将字符串的第一个字母转换为大写：

print(np.char.capitalize('monopoly'))
Monopoly

numpy.char.title()

numpy.char.title() 函数将字符串的每个单词的第一个字母转换为大写：

print(np.char.title('what matter'))
What Matter

numpy.char.lower()

numpy.char.lower() 函数对数组的每个元素转换为小写。它对每个元素调用 str.lower

print(np.char.lower('SDHIA'))
sdhia

numpy.char.split()

numpy.char.split() 通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格。

print(np.char.split('i like bob'))
['i', 'like', 'bob']

numpy.char.join()

numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串

print(np.char.join(':','kimodi'))
k:i:m:o:d:i

数学函数

三角函数

NumPy 提供了标准的三角函数：sin()、cos()、tan()。

a=np.array([0,30,45,90])
print(np.sin(a*np.pi/180))

舍入函数

numpy.around() 函数返回指定数字的四舍五入值。

numpy.around(a,decimals)

a=np.array([1.0,0.5])
print(np.around(a))
[1. 0.]

还有什么ceil和floor和cpp一样

算术函数

NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。

需要注意的是数组必须具有相同的形状或符合数组广播规则。