这篇博客介绍了Python中的numpy、matplotlib和scipy的使用，包括Numpy的向量操作，Matplotlib的图例语法与绘图，以及Scipy中的最小二乘法在曲线拟合中的应用。重点讲解了最小二乘法的概念及其在机器学习中的作用，以及如何利用scipy.optimize.leastsq函数进行非线性函数的参数拟合。
- 代码主要来源：邹博机器学习教程第四课python基础
Numpy 练习
np.arange(9)
生成的是列向量，并不是直观看到的行向量
# coding:utf-8
import numpy as np
import matplotlib as mpl
import scipy as sp
import math
import time
def residual(t, x, y):
return y - (t[0] * x**2 + t[1] * x + t[2])
def f(x):
y = np.ones_like(x)
i = x > 0
y[i] = np.power(x[i], x[i])
i = x < 0
y[i] = n.power(-x[i], -x[i])
return y
### 得到二维数组
# arange左闭右开，步长为10 reshape变换为任意行数，1列的列向量
# arange(6)为[0 1 2 3 4 5]
#广播机制：行向量与列向量相加，各自相加，形成矩阵
# a = np.arange(0, 60, 10).reshape((-1, 1)) + np.arange(6)
# print(a)
# b = np.arange(0, 60, 10).reshape(-1, 1) + np.arange(6)
# print(b)
# 结果：(a b相同)
# [[ 0 1 2 3 4 5]
# [10 11 12 13 14 15]
# [20 21 22 23 24 25]
# [30 31 32 33 34 35]
# [40 41 42 43 44 45]
# [50 51 52 53 54 55]]
### python中的list，元素的本质是对象，，对于us沪指计算比较浪费内存和CPU，计算较慢
### 所以使用numpy中的ndarray 加速计算
## 通过array传递list
# L = [1, 2, 3, 4, 5, 6]
# print(L)
# a = np.array(L)
# print(a)
# print(type(L), type(a))
# 传递多层嵌套的list,则是多维数组
# b = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
# print(b)
# 数组大小 通过其shape属性获得
# print(a.shape, b.shape)
# 强制修改shape 但是同时也改变了其原有结构
# 注：从(3,4)改为(4,3)并不是对数组进行转置，
# 而只是改变每个轴的大小，数组元素在内存中的位置并没有改变
# 当行或列为 -1 时表示不需要顾及它，按照另一个值进行修改shape，例如b.shape = -1, 5
# b.shape = 4, 3
# print(b)
# 使用reshape可以改变数组的尺寸,也可以创建改变了尺寸的新数组c,原数组的shape不变
# b = b.reshape(4, -1)
# c = b.reshape(6, -1)
# print(b)
# print(c)
# 这样得到的b和c共享内存，修改任意一个，另一个将改变
# b[0][1] = 20
# print(b)
# print(c)
# dtype属性：数组的元素类型
# print(a.dtype, b.dtype)
#创建数组时通过dtype指定元素类型
# d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype = np.float)
# e = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.complex)
# f = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.int)
# print(d)
# print(e)
# print(f)
# astype 更改元素类型，安全的转换
# g = d.astype(np.int)
# 但不要强制仅修改元素类型，如下面这句，将会以int来解释单精度float类型
# d.dtype = np.int
# print(d)
# 结果:
# [1, 2, 3, 4, 5, 6]
# [1 2 3 4 5 6]
# <class 'list'> <class 'numpy.ndarray'>
# [[ 1 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
# (6,) (3, 4)
# [[ 1 2 3]
# [ 4 5 6]
# [ 7 8 9]
# [10 11 12]]
# [[ 1 2 3]
# [ 4 5 6]
# [ 7 8 9]
# [10 11 12]]
# [[ 1 2]
# [ 3 4]
# [ 5 6]
# [ 7 8]
# [ 9 10]
# [11 12]]
# [[ 1 20 3]
# [ 4 5 6]
# [ 7 8 9]
# [10 11 12]]
# [[ 1 20]
# [ 3 4]
# [ 5 6]
# [ 7 8]
# [ 9 10]
# [11 12]]
# int32 int32
# [[ 1. 2. 3. 4.]
# [ 5. 6. 7. 8.]
# [ 9. 10. 11. 12.]]
# [[ 1.+0.j 2.+0.j 3.+0.j 4.+0.j]
# [ 5.+0.j 6.+0.j 7.+0.j 8.+0.j]
# [ 9.+0.j 10.+0.j 11.+0.j 12.+0.j]]
# [[ 1 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
# [[ 0 1072693248 0 1073741824 0 1074266112
# 0 1074790400]
# [ 0 1075052544 0 1075314688 0 1075576832
# 0 1075838976]
# [ 0 1075970048 0 1076101120 0 1076232192
# 0 1076363264]]
### np.arange(1, 20, 2) 左闭右开，步长为2，
### 和python中的range类似，但是range只能生成整数型，而arange可以生成浮点型
# 延长打印区域长度为100，不换行表示，并且不使用科学计数法显示
# np.set_printoptions(linewidth=100, suppress=True)
# a = np.arange(1, 10, 0.5)
# print(a)
# 结果：
# [1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. 5.5 6. 6.5 7. 7.5 8. 8.5 9. 9.5]
### linspace(1,10,5)函数 创建数组，左右全闭，从1开始到10结束，个数为5
# b = np.linspace(1, 10, 10)
# print(b)
# 通过endpoint关键词指定是否包含终值
# 相当于np.linspace(1, 10, 11)计算后去掉最后一个生成的数值
# c = np.linspace(1, 10, 10, endpoint=False)
# print('c = ', c)
# logspace(1, 5, 4, base=2) 创建等比数列，从2的1次方到2的5次方，取4个数；不标注的话默认底数为10
# d = np.logspace(1, 5, 4, endpoint=True, base=2)
# print(d)
# 结果：
# [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
# c = [1. 1.9 2.8 3.7 4.6 5.5 6.4 7.3 8.2 9.1]
# [ 2. 5.0396842 12.69920842 32. ]
### 使用 frombuffer, fromstring, fromfile等函数可以从字节序列创建数组
############## 这里不太懂，不会用 ##########################
# s = 'abcdzzzz'
# g = np.fromstring(s, dtype=np.int8) #转换成对应的ascII
# print(g)
# 结果：
# [ 97 98 99 100 122 122 122 122]
### 3.存取
### 3.1 常规办法：和python中list相同的方法
# a = np.arange(10)
# print(a)
# print(a[0]) #获取某个元素
# 以下均为切片操作
# 对于切片操作，切片数据是原数组的一个视图/引用（不算拷贝）
# 与原数组共享内存空间，可以直接修改元素值
# print(a[3:6]) #左闭右开
# print(a[3:])
# print(a[:4])
# print(a[:]) #所有
# print(a[1:9:2]) #步长为2
# print(a[9:1:-2]) #倒序，步长为2
# print(a[::-1]) #反转 reverse
# a[1:4] = 10, 20, 30 #修改数组
# print(a)
# b = a[2:5]
# print(b)
# b[0] = 200
# print(b)
# print(a)
# 结果：
# [0 1 2 3 4 5 6 7 8 9]
# 0
# [3 4 5]
# [3 4 5 6 7 8 9]
# [0 1 2 3]
# [0 1 2 3 4 5 6 7 8 9]
# [1 3 5 7]
# [9 7 5 3]
# [9 8 7 6 5 4 3 2 1 0]
# [ 0 10 20 30 4 5 6 7 8 9]
# [20 30 4]
# [200 30 4]
# [ 0 10 200 30 4 5 6 7 8 9]
### 3.2 整数/布尔数组存取 （索引）
### 3.2.1
### 整数数组存取（索引）：当使用整数序列对数组元素进行存取时，
### 将使用整数序列中的每个元素作为下标，整数序列可以是list或ndarray
### 使用整数序列作为下标获得的数组不与原数组共享数据空间
np.set_printoptions(suppress=True)
# a = np.logspace(0, 9, 10, base=2)
# print(a)
# i = np.arange(0, 10, 2)
# print(i)
#利用i取a中的元素
# b = a[i]
# print(b)
# b[2] = 111111
# print(b)
# print(a)
# 结果：
# [ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
# [0 2 4 6 8]
# [ 1. 4. 16. 64. 256.]
# [ 1. 4. 111111. 64. 256.]
# [ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
### 3.2.2
### 布尔数组i作为下标存取数组a中的元素（索引）
### 返回数组a中所有在数组b中对应下标为True的元素
### b与a不共享内存空间，不相互影响
a = np.random.rand(10) #生成10个满足[0, 1)中均匀分布的随机数
print(a)
print(a > 0.5) #布尔数组
b = a[a > 0.5]
print(b)
a[a > 0.5] = 0.5
print(a)
print(b)
# 结果：
# [0.59258726 0.86618547 0.35026646 0.44017041 0.51553528 0.00809087
# 0.57875341 0.63426188 0.80243144 0.42357513]
# [ True True False False True False True True True False]
# [0.59258726 0.86618547 0.51553528 0.57875341 0.63426188 0.80243144]
# [0.5 0.5 0.35026646 0.44017041 0.5 0.00809087
# 0.5 0.5 0.5 0.42357513]
# [0.59258726 0.86618547 0.51553528 0.57875341 0.63426188 0.80243144]
### 3.3 二维数组的切片
# a = np.arange(0, 60, 10) # 行向量
# print('a = ', a)
# b = a.reshape((-1, 1)) 
最低0.47元/天 解锁文章
扫一扫
739
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
