numpy简单使用

关注

原创最新推荐文章于 2026-08-28 16:09:05 发布 765 阅读 AI 写同款· GEO 优化 ›

Python 用 NumPy 实现简单的线性回归本文章的主要目的是详细介绍如何使用 Python 的 NumPy 库实现简单的线性回归。线性回归是一种基本的统计分析方法，用于建立自变量和因变量之间的线性关系。通过本文章，读者将深入理解线性回归的原理，掌握使用 NumPy 实现线性回归的具体步骤，并能够将其应用到实际的数据分析和预测任务中。本文的范围主要集中在简单线性回归，即只有一个自变量的情况。本文将按照以下结构进行组织：首先介绍线性回归的核心概念与联系，包括原理和架构；接着详细阐述核心算法原理及具体操作步骤，并使用 Python 源代码进行说明；阅读详情

ndarray、array、list的区别

1.python中的数组
- 用list和tuple等数据结构表示数组
  - 一维数组 List1 = [1, 2, 3]
  - 二维数组 Tuple1 = ([1, 2, 3], [4, 5, 6], [7, 8, 9])
    但是：列表是【动态指针数组】，它保存的是对象的指针，其元素可以是任意类型的对象。比如要保存上述的List1，需要3个指针和3个整数对象，浪费内存和计算时间。
- array模块（非内置模块）
  - 通过array函数创建数组 array.array()
  - 提供append、insert和read等方法
    但是：array模块中的array函数不支持多维数组，且函数功能不丰富。
2 NumPy中的N维数组ndarray
- NumPy中基本的数据结构
- 所有元素是同一种类型
- 别名array（数组）
- 节省内存，提高CPU计算时间
- 有丰富的函数
  总结：一个【内存空间连续】的、【相同的数据类型】【有序】的集合
  动态数组指针（引用）列表
注：NumPy的思维模式是面向数组。

numpty的引入

numpy是数据分析的【运算】基础
pandas数据分析的【业务】基础
数据类型构造函数运算函数访问方式
启动方式
1. cmd jupyter notebook
2. windows键 jupyter notebook
3. 在Anaconda里，点击Jupyter下的launch按钮启动
启动说明：
默认的启动路径是用户的根目录
调整根目录：使用cmd 到你想要的目录下，然后再启动
windows不能跨区访问如果想访问E盘，可以先cd到E盘，然后再启动
导入numpy库，并查看版本
```
  import numpy as np
  np.__version__
```

numpty的创建

直接用列表创建

arr1 = np.array([1,2,3,4,5])
注意：如果列表中有不同的数据类型，会被numpy强制数据类型统一
- np.array([1,2,3,“hello”]) =>
  array([‘1’, ‘2’, ‘3’, ‘hello’], dtype=’<U11’)
- 优先级：object>float>int

使用np的常规函数创建

np.ones(shape,dtype=None,order=‘C’)
- shape表达的是一个形状，一般用元组来表达,表示每个维度上数组的个数
- np.ones(shape=(3,2), dtype=np.int)
  =>array([[1, 1],
  [1, 1],
  [1, 1]])
np.zeros(shape, dtype=float, order=‘C’)
- np.zeros(shape=(5,5), dtype=np.int)
  => array([[0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0]])
np.full(shape, fill_value, dtype=None, order=‘C’)
- fill_value 表示要使用什么值来填充新数组
- np.full(shape=(3,3,3), fill_value=3)
  =>array([[[3, 3, 3],
  [3, 3, 3],
  [3, 3, 3]],
  
  [[3, 3, 3],
  [3, 3, 3],
  [3, 3, 3]],
  
  [[3, 3, 3],
  [3, 3, 3],
  [3, 3, 3]]])
np.eye(N, M=None, k=0, dtype=float)
对角线为1其他的位置为0
单位矩阵矩阵除法
N 代表行
M代表列, 默认是行=列
k是正数代表对角线元素右移，负数为左移
- np.eye(3,2,-1)
  =>array([[ 0., 0.],
  [ 1., 0.],
  [ 0., 1.]])
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
等差数列
start 起始值
stop 终止值
num 在数据区间，等差数列想获取的数据个数
endpoint 终止值是否作为取值范围内的数据
- np.linspace(1,10,num=10, endpoint=False)
  =>array([1. , 1.9, 2.8, 3.7, 4.6, 5.5, 6.4, 7.3, 8.2, 9.1])
np.arange([start, ]stop, [step, ]dtype=None)
start 可以省略，如果省略默认值0
step 表示步长,默认是1
- np.arange(10)
  => array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
np.random.randint(low, high=None, size=None, dtype=‘l’)
[low,higt) 表示一个区间左闭右开
size表示数组的维度，用元组表示，和shape一样
- np.random.randint(0,10,size=(3,4))
  =>array([[1, 2, 9, 0],
  [3, 9, 9, 3],
  [0, 6, 9, 3]])
np.random.randn(d0, d1, …, dn)
标准正态分布又称为u分布，是以0为均值、以1为标准差的正态分布，记为N（0，1）
- np.random.randn(3,2) =>
  array([[-0.14398458, -0.47286995],
  [ 0.95427434, 0.64911753],
  [-0.66431491, 1.70914539]])
normal(loc=0.0, scale=1.0, size=None)
正态分布，loc为期望，scale为标准方差
- data = np.random.normal(loc=175,scale=8,size=(10))
  => array([ 160.11352464, 174.16032546, 158.84265376, 178.67574759,
  166.42684487, 166.81504329, 171.39961295, 172.20360447,
  160.59687194, 171.80781779])
np.random.random(size=None)
生成0到1的随机数，左闭右开
- np.random.random(size=(3,2))
把数据展示成图形
- import matplotlib.pyplot as plt
  %matplotlib inline
- 直方图表达数据分布的图像
  plt.hist(data, density=True)

ndarray的属性

shape 元素的形状，各维度的长度

arr = np.ones(shape=(3,5))
arr ⇒  
arr.shape	==> (3, 5)
arr.size ==>15
arr.ndim ==>2

arr8 = np.array([1,2,1.3])
arr8.dtype ==>dtype('float64')  浮点型
dtype('O')  表示object类型
dtype('int32') 整形

ndim 数组的维度
size 元素的个数
dtype 元素类型

ndarray变形

使用reshape函数，注意参数是一个tuple！
变形必须要保证变形后的数据个数与变形前一致

arr1 = np.random.random(size=(3,4))
arr1 ==>  3行4列
array([[0.07799376, 0.74508731, 0.83643786, 0.25775686],
      [0.30486044, 0.80641823, 0.37152967, 0.40286362],
      [0.56863387, 0.86737528, 0.23595391, 0.39742841]])
#变成1行12列
arr1.reshape((1,12))  ==>
array([[0.07799376, 0.74508731, 0.83643786, 0.25775686, 0.30486044,
       0.80641823, 0.37152967, 0.40286362, 0.56863387, 0.86737528,
       0.23595391, 0.39742841]])
#变成 12行1列
arr1.reshape((12,1))
#同arr1.reshape((1,12))
arr1.reshape((12,))

ndarray的基本操作

索引

一维与列表完全一致多维时同理

arr1 = np.random.randint(0,100,size=(10))
arr1	==>array([17, 88, 11, 19, 89, 70,  9, 32, 78, 25])
#通过下标形式访问（同列表）
arr1[-1] ==>25
arr1[::2] ==>array([17, 11, 89,  9, 78])

#可以使用列表作为索引，读取到的内容是一个子数组
【重点】
arr1[[1,3]] ==> array([88, 19])
#可以使用列表对原始数组的数据进行重新排列
【重点】
arr1[[1,3,1,3,1,3]] ==> array([88, 19, 88, 19, 88, 19])

多维数组的索引
访问元素二维数组
arr[index, column]
- 访问行
  1行 arr[index]
  多行 arr[[index1,index2…indexn]]
- 访问列
  1列 arr[:,column]
  多列 arr[:,[column1,column2…columnn]]

arr4 = np.random.randint(0,100,size=(6,6))
arr4  ==>
array([[13, 66, 43, 21, 25, 11],
       [66, 85, 46, 11, 57, 68],
       [44, 30, 48, 83, 25,  4],
       [85, 30,  5, 31, 31, 11],
       [79, 55, 82, 15, 81, 99],
       [38, 10, 47, 38, 99,  6]])

# list的访问方式
arr4[-1][-1] ==> 6
arr4[0][[0,1]] ==>array([13, 66])

#二维数组的行列访问
#行访问
arr4[[0,1]] ==>
array([[13, 66, 43, 21, 25, 11],
       [66, 85, 46, 11, 57, 68]])
#列访问
arr4[:,0] ==>
array([13, 66, 44, 85, 79, 38])
#多列访问
arr4[:,[0,1]]
arr4[:,0:2]
#块访问
arr4[0:,[0,1]]
array([[92, 30],
       [37,  8],
       [82, 56],
       [62, 53],
       [57,  5],
       [59, 66]])

切片

一维与列表完全一致多维时同理
切片是左闭右开区间

元素访问

array([[55, 12, 23, 77, 20],
       [46, 32, 17, 76, 37],
       [89, 57, 19, 88, 65],
       [43, 85, 69, 67, 38],
       [21, 40, 96, 37, 53]])
#行访问
arr[:2]  ==>array([[55, 12, 23, 77, 20],
       [46, 32, 17, 76, 37]])
#列访问
arr[:,3:] ==> 
array([[77, 20],
       [76, 37],
       [88, 65],
       [67, 38],
       [37, 53]])
#块访问
arr[1:3,2:4]  ==>
array([[17, 76],
       [19, 88]])

行列转置

arr2 = np.random.randint(0,10,size=(3,4))
arr2 ==>
array([[9, 7, 1, 4],
       [5, 4, 6, 8],
       [1, 0, 1, 7]])
#行转置
arr2[::-1]
array([[1, 0, 1, 7],
       [5, 4, 6, 8],
       [9, 7, 1, 4]])
#列转置
arr2[:,::-1]
array([[4, 1, 7, 9],
       [8, 6, 4, 5],
       [7, 1, 0, 1]])


# 图片转置
import matplotlib.pyplot as plt
%matplotlib inline
# 读取一张图片
tk = plt.imread('T.jpg')
plt.imshow(tk)
#通过列转置将图片沿着竖轴旋转180度
tk1 = tk[:,::-1]
plt.imshow(tk1)

#使用numpy方法转置
#转置为列
np.vstack(np.arange(0,5))	==>
array([[0],
       [1],
       [2],
       [3],
       [4]])
#转置为行
np.hstack(np.vstack(np.arange(0,5)))	==>
array([0, 1, 2, 3, 4])

级联

concatenate((a1, a2, …), axis=0)

np.concatenate() 级联需要注意的点：
级联的参数是列表：一定要加中括号或小括号
维度必须相同
形状相符
【重点】级联的方向默认是shape这个tuple的第一个值所代表的维度方向
可通过axis参数改变级联的方向

arr1 = np.random.randint(0,100,size=(2,3))
arr2 = np.random.randint(100,110, size=(2,4))
# display相当于print函数
display(arr1, arr2)  ==>
array([[16, 74, 69],
       [26, 93, 23]])
array([[108, 103, 101, 103],
       [102, 103, 105, 106]])

#水平级联 axis是1
np.concatenate((arr1, arr2), axis=1) ==>
array([[ 16,  74,  69, 108, 103, 101, 103],
       [ 26,  93,  23, 102, 103, 105, 106]])

np.hstack水平级联

np.hstack((arr1, arr2)) ==>
array([[ 16,  74,  69, 108, 103, 101, 103],
       [ 26,  93,  23, 102, 103, 105, 106]])

np.vstack 垂直级联 ==>报错，形状不相符

切分

np.split(ary, indices_or_sections, axis=0)
np.vsplit(ary, indices_or_sections)
np.hsplit(ary, indices_or_sections)
【注意】：indices_or_sections int类型，表示要切分的份数平均分
需要保证，在切分的维度上的数据个数，必须能被indices_or_sections这个值整除

np.vsplit 垂直切分

arr1 = np.random.randint(0,100,size=(6,4))
arr1 ==>
array([[79, 95,  8, 77],
       [25, 78, 99,  5],
       [96, 91, 74,  9],
       [11, 26, 65, 21],
       [89, 40, 52, 65],
       [93, 48, 41, 12]])
#切三份
np.vsplit(arr1, 3)  ==>
[array([[79, 95,  8, 77],
        [25, 78, 99,  5]]), array([[96, 91, 74,  9],
        [11, 26, 65, 21]]), array([[89, 40, 52, 65],
        [93, 48, 41, 12]])]
#按列表格式切成三个区间[m,n]  0:2, 2:4, 4:
np.vsplit(arr1, [2,4])  ==>
[array([[79, 95,  8, 77],
        [25, 78, 99,  5]]), array([[96, 91, 74,  9],
        [11, 26, 65, 21]]), array([[89, 40, 52, 65],
        [93, 48, 41, 12]])]

np.hsplit() 水平切分同垂直切分
np.spilt()

arr3 = np.random.randint(0,100,size=(3,8))
arr3  ==>
array([[77, 45, 56,  7,  2, 44, 72, 65],
       [82, 79, 46, 87,  0, 57, 88, 85],
       [43, 88, 62, 33, 74, 59, 33, 28]])
# 水平切分成三份       
np.split(arr3, indices_or_sections=[3,4],axis=1)  ==>
[array([[77, 45, 56],
        [82, 79, 46],
        [43, 88, 62]]), array([[ 7],
        [87],
        [33]]), array([[ 2, 44, 72, 65],
        [ 0, 57, 88, 85],
        [74, 59, 33, 28]])]

副本

所有赋值运算不会为ndarray的任何元素创建副本。对赋值后的对象的操作也对原来的对象生效（赋值）
可使用copy()函数创建副本

arr = np.random.randint(0,10,size=1)
arr ==>
array([5])
# 浅拷贝
arr1 = arr
arr1[0]  ==>
5

ndarray的聚合操作

常见的聚合操作
Function Name NaN-safe Version Description
np.sum np.nansum Compute sum of elements
np.prod np.nanprod Compute product of elements
np.mean np.nanmean Compute mean of elements
np.std np.nanstd Compute standard deviation
np.var np.nanvar Compute variance
np.min np.nanmin Find minimum value
np.max np.nanmax Find maximum value
np.argmin np.nanargmin Find index of minimum value
np.argmax np.nanargmax Find index of maximum value
np.median np.nanmedian Compute median of elements
np.percentile np.nanpercentile Compute rank-based statistics of elements
np.any N/A Evaluate whether any elements are true
np.all N/A Evaluate whether all elements are true
np.power 幂运算
【注意】np.sum 和 np.nansum 的区别 nan not a number
一维

arr = np.array([1,2,8,4,5])
#求和
arr.sum() ==>20
#最小值
arr.min() ==>1
#最大值的索引
arr.argmax() ==> 2

多维


arr1 = np.ones(shape=(2,5))
arr1  ==>
array([[1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.]])
#垂直方向
arr1.sum(axis=0)   ==>
array([2., 2., 2., 2., 2.])
#水平方向
arr1.sum(axis=1)  ==>
array([5., 5.])

any()和all()
any() 有True返回True
all() 有False返回False

arr1 = np.array([True,False,False])

# 有一个True,就返回True
arr1.any()  ==>True
arr1.all()  ==>False

ndarray的矩阵操作

基本矩阵操作

算术运算符

a1 = np.random.randint(0,10,size=(3,3))
a2 = np.ones(shape=(3,3))
display(a1, a2) ==>
array([[7, 2, 5],
       [2, 9, 8],
       [6, 6, 8]])
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

a1 + a2 ==> 加法

array([[ 8.,  3.,  6.],
       [ 3., 10.,  9.],
       [ 7.,  7.,  9.]])
a1 * a2  ==> 乘法
array([[7., 2., 5.],
       [2., 9., 8.],
       [6., 6., 8.]])

矩阵积np.dot()

a1 = np.array([[1,2],[3,4]])
a2 = np.array([[1,1],[1,1]])
np.dot(a1,a2)  ==>
array([[3, 3],
       [7, 7]])
#默认的运算 对应位置运算
# 矩阵运算   需要使用dot函数

广播机制

【重要】ndarray广播机制的两条规则

 规则一：为缺失的维度补1
规则二：假定缺失元素用已有值填充

# 一个数组维度不全
m = np.ones((2, 3))
a = np.arange(3)
m + a  ==>将a变成 [[0,1,2],[0,1,2]] 再相加
array([[ 1.,  2.,  3.],
       [ 1.,  2.,  3.]])
       
#两个数组维度不全
a = np.arange(3).reshape((3, 1))
b = np.arange(3)
a + b	==>
a变成 [[0,0,0],[1,1,1,],[2,2,2]]
b变成 [[0,1,2],[0,1,2],[0,1,2]]
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4]])
#0维和其他维运算
arr2 = np.array([[ 9, 10, 10, 11,  5],
       [10, 10, 10,  3,  6]])

arr2 + 2 ==>
array([[ 9, 10, 10, 11,  5],
       [10, 10, 10,  3,  6]])


#不支持的运算
# 形状上不支持广播
a = np.ones((3,2))
b = np.ones(4)
a + b

ndarray的排序

快速排序
np.sort()与ndarray.sort()都可以，但有区别：
np.sort()不改变输入
ndarray.sort()本地处理，不占用空间，但改变输入

#不改变原始输入
arr1 = np.array([2,3,6,1,7,9,4,5,8,0])
result = np.sort(arr1)
result  ==>
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# 改变原始输入
arr1.sort()
arr1 ==>
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

部分排序
np.partition(a, kth, axis=-1, kind=‘introselect’, order=None)

创建一个数组的副本，其中的元素被重新排列，使位于第k个位置的元素的值位于排序后的数组中的位置。所有小于第k个元素的元素都在这个元素之前移动，所有相等或更大的元素都在后面移动。两个分区中元素的顺序没有定义。

arr1 = np.array([2,3,6,1,7,9,4,5,8,0])
#第二个 位置排序
np.partition(arr1, 2)  ==>
array([0, 1, 2, 3, 7, 9, 4, 5, 8, 6])	# 只有第二个元素的位置是可靠排序，
#倒数第二个
np.partition(arr1, -2)	==>
array([1, 0, 2, 3, 4, 5, 6, 7, 8, 9])	# 只有倒数第二个元素的位置是可靠排序