在电子商务网站建设中需要哪些知识,网站建设平台招商,中国建筑网官网图片,东莞什么平台好做文章目录 前言数据预处理——sklearn.preprocessing数据标准化数据归一化另一种数据预处理数据二值化异常值处理 numpy 相关用法跳过 nan 值的方法——nansum和nanmean展开多维数组#xff08;变成类似list列表的形状#xff09;重复一个数组——np.tile 分组聚集——pandas.… 文章目录 前言数据预处理——sklearn.preprocessing数据标准化数据归一化另一种数据预处理数据二值化异常值处理 numpy 相关用法跳过 nan 值的方法——nansum和nanmean展开多维数组变成类似list列表的形状重复一个数组——np.tile 分组聚集——pandas.DataFrame.groupby()如何使用直接使用聚集函数Agg直接解析分组结果 参数说明——by传入属性列列表传入字典 dict 表格合并——pandas.merge()数据库关系型表格 → 二维表——pandas.DataFrame.pivot()序列极值的获取——scipy.signal.argrelextrema 前言 使用 Python 进行数学建模时需要进行各种各样的数据预处理。因此熟练掌握 Python 的一些库可以帮助我们更好的进行数学建模。
数据预处理——sklearn.preprocessing
数据标准化 数据标准化的目的是通过线性缩放使得一组数据的均值变成 0 0 0方差变成 1 1 1。使用scale方法
from sklearn import preprocessing
import numpy as npdata np.array([[1.,1.,4.,5.],[1.,4.,1.,9.],[1.,9.,8.,1.]])
# 默认按列标准化(axis 0)如需按行标准化需要指定 axis 1
print(preprocessing.scale(data))# 结果如下原本方差为 0 的数据标准化后方差仍然是 0因为无法变成1
#[[ 0. -1.1111678 -0.11624764 0. ]
# [ 0. -0.20203051 -1.16247639 1.22474487]
# [ 0. 1.31319831 1.27872403 -1.22474487]]我们知道标准化的实质是减去均值、除以标准差。StandarScalar可以用一组数据的均值、方差去标准化另一组数据。比如
from sklearn import preprocessing
import numpy as npdata np.array([[1.,1.,4.,5.],[1.,4.,1.,9.],[1.,9.,8.,1.]])
scaler preprocessing.StandardScaler().fit(data)
new_data np.array([[9.,2.,3.,4.]])# 用 data 的均值、标准差去标准化 new_data
print(scaler.transform(new_data))
# 结果为 [[ 8. -0.80812204 -0.46499055 -0.30618622]]数据归一化 数据归一化指的是通过线性缩放使得一组数据的最小值为 0 0 0最大值为 1 1 1。**实质是全体减去最小值然后除以减法过后的最大值。**可以使用MinMaxScaler类
from sklearn import preprocessing
import numpy as npdata np.array([[1.,1.,4.,5.],[1.,4.,1.,9.],[1.,9.,8.,1.]])
# 创建 scaler
scaler preprocessing.MinMaxScaler()print(scaler.fit_transform(data))
# 结果是
#[[0. 0. 0.42857143 0.5 ]
# [0. 0.375 0. 1. ]
# [0. 1. 1. 0. ]]# 同样可以用 data 的缩放方式来归一化 new_data
new_data np.array([[1,0,3,7]])
print(scaler.transform(new_data))
# 结果为 [[ 0. -0.125 0.28571429 0.75 ]]另一种数据预处理 还有一种数据预处理是对初始数据 { x 1 , x 2 , ⋯ , x n } \{x_1,x_2,\cdots,x_n\} {x1,x2,⋯,xn} 都除以 max 1 ≤ i ≤ n ∣ x i ∣ \max\limits_{1\leq i\leq n}|x_i| 1≤i≤nmax∣xi∣使得所有数据都落在 [ − 1 , 1 ] [-1,1] [−1,1] 范围内。MaxAbsScaler类可以完成这种预处理其用法和前面的MinMaxScaler类似。这个方法对那些已经中心化均值为 0 0 0 或者稀疏的数据有意义。
数据二值化 数据二值化设置一个阈值threshold小于等于它的变成 0 0 0大于它的变成 1 1 1。
from sklearn import preprocessing
import numpy as npdata np.array([[1.,1.,4.,5.],[1.,4.,1.,9.],[1.,9.,8.,1.]])
# Binarizer 无参数默认 threshold 0
print(preprocessing.Binarizer(threshold 1).transform(data))
# 结果为
#[[0. 0. 1. 1.]
# [0. 1. 0. 1.]
# [0. 1. 1. 0.]]参考文献预处理数据的方法总结使用sklearn-preprocessing_from sklearn import preprocessing-CSDN博客
异常值处理 四分位法清除异常值首先计算出序列的第一四分位数、第三四分位数 Q 1 , Q 3 Q_1,Q_3 Q1,Q3然后计算四分位数间距 I Q R Q 3 − Q 1 \mathit{IQR}Q_3-Q_1 IQRQ3−Q1。认为可接受的数据范围是 [ Q 1 − 1.5 I Q R , Q 3 1.5 I Q R ] [{{Q}_{1}}-1.5\mathit{IQR},{{Q}_{3}}1.5\mathit{IQR}] [Q1−1.5IQR,Q31.5IQR]。如下图 图源来自图片水印所示博客。 import pandas as pd# 直接把数据从这里输入进来
data pd.Series([1,1,4,5,1,4,1,9,1,9,8,1,0])Q1 data.quantile(0.25)
Q3 data.quantile(0.75)
IQR Q3 - Q1
# 根据条件筛选和删除异常值输出的 data 就是处理后的结果
data data[~((data (Q1 - 1.5 * IQR)) | (data (Q3 1.5 * IQR)))]numpy 相关用法
跳过 nan 值的方法——nansum和nanmean
import numpy as nparr np.array([1, 2, 3, 4, np.nan])
print(arr.sum(),arr.mean()) # nan nan
print(np.nansum(arr),np.nanmean(arr)) # 10.0 2.5相当于删除所有 nan 值再操作展开多维数组变成类似list列表的形状
import numpy as nparr np.array(range(16)).reshape(4,-1)print(arr)[[ 0 1 2 3][ 4 5 6 7][ 8 9 10 11][12 13 14 15]]# 下面三种方法任选其一即可
print(arr.ravel())
# [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]
print(arr.flatten())
# [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]
print(arr.reshape(-1))
# [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]重复一个数组——np.tile
import numpy as np# 只描述对于 2 维数组的情况其他详情见参考文献data np.array([[1,1,4],[5,1,4]])# 只传一个参数 x那么行方向重复 x 次
print(np.tile(data,3))[[1 1 4 1 1 4 1 1 4][5 1 4 5 1 4 5 1 4]]
# 传一个含有两个参数的元组 (x,y)那么列方向重复 x 次行方向重复 y 次
print(np.tile(data,(2,4)))[[1 1 4 1 1 4 1 1 4 1 1 4][5 1 4 5 1 4 5 1 4 5 1 4][1 1 4 1 1 4 1 1 4 1 1 4][5 1 4 5 1 4 5 1 4 5 1 4]]参考文献numpy.tile()_np.tile-CSDN博客
分组聚集——pandas.DataFrame.groupby() 对于一个表格进行类似 MySQL 聚集函数的处理该方法的参数及默认值
DataFrame.groupby(byNone, axis0, levelNone, as_indexTrue,sortTrue, group_keysTrue, squeezeFalse, observedFalse, dropnaTrue) 如何使用
直接使用聚集函数 方法得到的是一个对象对于该对象可以使用聚集函数。比如下面的例子
import pandas as pddf pd.DataFrame({A: [1, 2, 3, 4],B: [5, 6, 7, 8],C: [X, X, Y, Y]
})# 聚集函数——均值mean()还可以是最大值max(),最小值min(),
# 求和sum(),求积prod(),计数count(),标准差std(),各种统计数据describe()等。
print(df.groupby(C).mean()) # 即参数 by C
# 结果如下所示
# A B
# C
# X 1.5 5.5
# Y 3.5 7.5print(df.groupby(C).rank())
# 结果如下所示
# A B
# 0 1.0 1.0
# 1 2.0 2.0
# 2 1.0 1.0
# 3 2.0 2.0Agg agg 在基于相同的分组情况下可以对不同列分别使用不同的聚集函数如
import pandas as pddf pd.DataFrame({A: [1, 2, 3, 4],B: [5, 6, 7, 8],C: [X, X, Y, Y]
})# 对 A 列分组求最小值对 B 列分组求最大值
print(df.groupby(C).agg({A:min,B:max}))# 结果如下所示
# A B
# C
# X 1 6
# Y 3 8也可以传入自定义函数比如上面的B:max也可以等价地改为B:lambda x : max(x)其中参数x是由 agg 分组形成的元组。
直接解析分组结果 有时候希望根据分组结果一组显示一张表格。直接打印 groupby 后的对象是不行的
import pandas as pddf pd.DataFrame({name: [香蕉, 菠菜, 糯米, 糙米, 丝瓜, 冬瓜, 柑橘, 苹果, 橄榄油],category: [水果, 蔬菜, 米面, 米面, 蔬菜, 蔬菜, 水果, 水果, 粮油],price: [3.5, 6, 2.8, 9, 3, 2.5, 3.2, 8, 18],count: [2, 1, 3, 6, 4, 8, 5, 3, 2]
})print(df.groupby(category))
# 结果只是类名 内存地址
# pandas.core.groupby.generic.DataFrameGroupBy object at 0x0000025D2D49B6D8但是我们可以按照下面的方式遍历其中循环变量name为str类型group为DataFrame类型
import pandas as pddf pd.DataFrame({name: [香蕉, 菠菜, 糯米, 糙米, 丝瓜, 冬瓜, 柑橘, 苹果, 橄榄油],category: [水果, 蔬菜, 米面, 米面, 蔬菜, 蔬菜, 水果, 水果, 粮油],price: [3.5, 6, 2.8, 9, 3, 2.5, 3.2, 8, 18],count: [2, 1, 3, 6, 4, 8, 5, 3, 2]
})
result df.groupby(category)for name, group in result:print(fgroup name: {name})print(- * 30)print(group)print( * 30, \n)group name: 水果
------------------------------name category price count
0 香蕉 水果 3.5 2
6 柑橘 水果 3.2 5
7 苹果 水果 8.0 3group name: 米面
------------------------------name category price count
2 糯米 米面 2.8 3
3 糙米 米面 9.0 6group name: 粮油
------------------------------name category price count
8 橄榄油 粮油 18.0 2group name: 蔬菜
------------------------------name category price count
1 菠菜 蔬菜 6.0 1
4 丝瓜 蔬菜 3.0 4
5 冬瓜 蔬菜 2.5 8参数说明——by 上面使用都是by C等传入某一个属性列的方式。
传入属性列列表 如果要按照多个属性列分组可以传入属性列列表如下所示
import pandas as pddf pd.DataFrame({x:[1,1,1,1,2,2,2,2],y:[3,3,4,4,3,3,4,4],value:[1,1,4,5,1,4,1,9]
})
# 按照 (x,y) 分组并求取最大值
print(df.groupby([x,y]).max())结果是value
x y
1 3 14 5
2 3 44 9groupby 接收多个属性会将这些属性全部变成索引。之后可以接上reset_index操作传入参数level可以将第level列索引变成属性。
传入字典 dict 要求字典是int到str的映射。这种情况下将不会按照df中原有的列进行分组而是根据字典的内容将原来df中的某一行映射到字典对应的类中。例如
import pandas as pddf pd.DataFrame({name: [香蕉, 菠菜, 糯米, 糙米, 丝瓜, 冬瓜, 柑橘, 苹果, 橄榄油],category: [水果, 蔬菜, 米面, 米面, 蔬菜, 蔬菜, 水果, 水果, 粮油],price: [3.5, 6, 2.8, 9, 3, 2.5, 3.2, 8, 18],count: [2, 1, 3, 6, 4, 8, 5, 3, 2]
})# 下面这 5 行是为了自动化地得到字典
# {0: 蔬菜水果, 1: 蔬菜水果, 2: 米面粮油, 3: 米面粮油, 4: 蔬菜水果,
# 5: 蔬菜水果, 6: 蔬菜水果, 7: 蔬菜水果, 8: 米面粮油}
category_dict {水果: 蔬菜水果, 蔬菜: 蔬菜水果, 米面: 米面粮油, 粮油: 米面粮油}
the_map {}
for i in range(len(df.index)):the_map[i] category_dict[df.iloc[i][category]]
grouped df.groupby(the_map)# 按照 the_map 进行分组那么原 df 中第 0,1,4,5,6,7 行被归为“蔬菜水果”
# 第 2,3,8 行被归为“米面粮油”
result df.groupby(the_map)# 按照不同类别进行打印
for name, group in result:print(fgroup name: {name})print(- * 30)print(group)print( * 30, \n)结果为
group name: 米面粮油
------------------------------name category price count
2 糯米 米面 2.8 3
3 糙米 米面 9.0 6
8 橄榄油 粮油 18.0 2group name: 蔬菜水果
------------------------------name category price count
0 香蕉 水果 3.5 2
1 菠菜 蔬菜 6.0 1
4 丝瓜 蔬菜 3.0 4
5 冬瓜 蔬菜 2.5 8
6 柑橘 水果 3.2 5
7 苹果 水果 8.0 3参考文献深入理解 Pandas 中的 groupby 函数_observedfalse-CSDN博客
表格合并——pandas.merge() 这个merge和 MySQL 的 join 是有几分相似的。该方法的参数和默认值
DataFrame.merge(left, right, howinner, onNone, left_onNone, right_onNone,left_indexFalse, right_indexFalse, sortTrue,suffixes(_x, _y), copyTrue, indicatorFalse,validateNone)其中how还可以是left,right,outer对应 MySQL 中的左、右、外连接MySQL 中连接产生的 null 在 Python 中变成 nan。on可以指定链接的时候参照那些属性列。默认情况下on None即自然连接。不常用indicator参数在最终合并形成的表格中加入一个_merge列值域为{left_only,both,right_only}描述每一条结果是如何连接形成的。例子如下
import pandas as pddf1 pd.DataFrame({col1: [0, 1], col_left:[a, b]})
df2 pd.DataFrame({col1: [1, 2, 2],col_right:[2, 2, 2]})
print(pd.merge(df1, df2, oncol1, howouter, indicatorTrue))结果如下所示col1 col_left col_right _merge
0 0 a NaN left_only
1 1 b 2.0 both
2 2 NaN 2.0 right_only
3 2 NaN 2.0 right_only参考文献【python】详解pandas库的pd.merge函数-CSDN博客
数据库关系型表格 → 二维表——pandas.DataFrame.pivot() 标题的意思是这样的已有一个关系型数据库可以指定两个索引行索引、列索引以及对应的值索引转化为一个二维表格。如下图所示。 如果图片左边的 DataFrame 是变量 data通过下面的语句实现到右边表格的转换
data.pivot(name,year,gdp) 函数原型是
DataFrame.pivot(indexNone, columnsNone, valuesNone)右边二维表行列索引的生成机制是 index 和 columns 的笛卡尔积。笛卡尔积集合中可能有不存在的 (index, columns) 组合经过pivot处理变成 nan如
import pandas as pd
data pd.DataFrame({name:[原神,原神,星铁,星铁,星铁],year:[2022,2023,2022,2023,2024],income:[11,21,31,41,51]
})
print(data,\n,- * 24)
print(data.pivot(name,year,income))
name year income
0 原神 2022 11
1 原神 2023 21
2 星铁 2022 31
3 星铁 2023 41
4 星铁 2024 51 ------------------------
year 2022 2023 2024
name
原神 11.0 21.0 NaN
星铁 31.0 41.0 51.0不能存在相同的 (index, columns) 组合
import pandas as pd
data pd.DataFrame({name:[原神,原神],year:[2022,2022],income:[11,21]
})
print(data.pivot(name,year,income))
# ValueError: Index contains duplicate entries, cannot reshape参考文献Python dataframe.pivot()用法解析_dataframe pivot-CSDN博客
序列极值的获取——scipy.signal.argrelextrema 已知一个序列可以用这个库方便地求极大值和极小值。代码示例如下
from scipy.signal import argrelextrema
import numpy as np
# y 是待求序列
y np.array([1,9,6,8,2,5,8,3,2,7,3,2,7,5])# np.greater_equal 表示求极大值order 1 表示和左边、右边的 1 个数字对比是极大值的定义
peak_index argrelextrema(y,np.greater_equal,order1)print(peak_index)结果 (array([ 1, 3, 6, 9, 12], dtypeint64),)
peak_index[0] 给出了极大值点的数组上面使用np.greater_equal求极大值点同样地我们可以使用np.less_equal求极小值点。甚至可以自定义函数将上面代码第 7 行改为
peak_index argrelextrema(y,lambda a,b: a - b 3,order1)这将返回比左、右两边元素都大 3 3 3 的所有元素此例中只有y[9]的索引此例为9。 参考文献数据分析——scipy.signal.argrelextrema求数组中的极大值和极小值-CSDN博客
