python数据分析三剑客

本文主要对Numpy，Pandas和Matplotlib常用方法进行了粗略的整理。。。

图像处理方式

# 显示中文（因为横纵坐标想要显示中文的）
plt.rcParams['font.sans-serif'] = ['SimHei']# 显示负数
plt.rcParams['axes.unicode_minus'] = False#画布大小
plt.figure(1, figsize=(8, 6),dpi=100)  # 设置图片大小 dpi的设置可以让图片更加清晰# 快速保存多张图片plt.savefig('images/%d.png' % (i + 1))

Numpy

文件操作

保存文件 np.savetxt()

语法结构:

savetxt(fname, X, fmt=’%.18e’, delimiter=’ ‘, newline=’\n’, header=’’, footer=’’, comments=’# ', encoding=None).

Parameters	说明
fname	文件，字符串或者产生器，可以是.gz或.bz2的压缩文件
array	存入文件的数组
fmt	写入文件的格式，例如：%d %.2f %.18e
delimiter	分割字符串，默认是任何空格
header	文件头部信息

a = np.random.randint(60, 100, size=(20, 2))np.savetxt('datas/score.csv', a,
delimiter=',', header='英语,数学', comments=' ',fmt='%d')

读取文件 np.loadtxt()

语法结构:

loadtxt(fname, dtype=<class ‘float’>, comments=’#’, delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding=‘bytes’, max_rows=None)

Parameters	说明
fname	文件，字符串或者产生器，可以是.gz或.bz2的压缩文件
dtype	数据类型,可选.
skiprows	跳过前面x行.
usecols	读取指定的列,用元组组合.
unpack	如果True,读取出来的数据是转置后的.
delimiter	分割字符串，默认是任何空格
encoding	对读取的文件进行预编码
converters	对读取的数据进行预处理
comments	跳过文件中指定参数开头的行（即不读取）

a = np.random.randint(60, 100, size=(20, 2))np.savetxt('datas/score.csv', a,
delimiter=',', header='英语,数学', comments=' ',fmt='%.2f')b = np.loadtxt('datas/score.csv',dtype=np.float,delimiter=',',skiprows=1)
print(b)

NAN和INF

import numpy as np# 知识点一：删除NAN
# np.nan是np.float类型的
# 1.删除所有nan的值,因为删除了值之后数组将不知道该怎么变化,所以会变成一维数组
data = np.random.randint(0, 10, size=(3, 5)).astype(np.float64)
data[0, 1] = np.nan
# np.isnan() 用以识别np.nan
data = data[~np.isnan(data)]  # 此时的data会没有nan,并且变成一个一维数组
print(data)# 2.删除NAN所在的行
data = np.random.randint(0, 10, size=(3, 5)).astype(np.float64)
data[[0, 1], [1, 2]] = np.nan# 获取哪些行有NAN
lines = np.where(np.isnan(data))[0]  # 满足条件的元素的行与列，加个[0]便获得行# 使用delete方法删除指定的行,axis=0表示删除行,lines表示删除的行号
data1 = np.delete(data, lines, axis=0)
print(data1)# 知识点二：替换NAN# 读取含有空值的一般方法
scores = np.loadtxt('datas/score.csv', delimiter=',', skiprows=1, encoding='gbk', dtype=np.str_)
scores[scores == ""] = np.nan
scores1 = scores.astype(np.float64)
scores1[np.isnan(scores1)] = 0# 按行求和 axis = 1 这表示按行
scores1 = scores1.sum(axis=1)
print(scores1)scores2 = scores.astype(np.float64)
for x in range(scores2.shape[1]):col = scores2[:, x]non_nan_col = col[~np.isnan(col)]mean = non_nan_col.mean()col[np.isnan(col)] = meanprint(scores2)

索引和切片

[[ 1  2  3  4  5  6][ 7  8  9 10 11 12][13 14 15 16 17 18][19 20 21 22 23 24]]1。 bool索引
b = b[b < 10]  # b = [1 2 3 4 5 6 7 8 9]# b = [ 1  2  3  4  5  6  7  8  9 16 17 18 19 20 21 22 23 24]
b = b[(b < 10) | (b > 15)]  & 且 | 或             2。二维索引
第一个表示行，第二个表示列
1>连续型      a = b[1:3, 1:5]
2>不连续型    a = b[[1, 3], [2, 4]]
3>结合版      a = b[:, [1, 3]]
4>设置步长为2 a = b[:, [1, 3]][::2]

四则运算

1.np.multiply(a, b)

作用：对两个数组的对应位置的元素进行相乘，因此它要求这两个数组有相同的大小(shape相同)，相同则是计算内积。如果shape不同的话，会将小规格的矩阵延展成与另一矩阵一样大小，再求两者内积。

2.np.dot()

作用: 主要用于矩阵的乘法运算，其中包括：向量内积、多维矩阵乘法和矩阵与向量的乘法。

"""
1. 向量内积
向量其实是一维的矩阵,两个向量进行内积运算时,需要保证两个向量包含的元素个数是相同的.
(计算过程就是将向量中对应元素相乘,再相加所得.即普通的向量乘法运算)
x = np.array([1, 2, 3, 4, 5, 6, 7])
y = np.array([2, 3, 4, 5, 6, 7, 8])
result = np.dot(x, y)
print(result)  # 1682. 矩阵与向量乘法(不满足交换律)
矩阵x为m×n阶,向量y为n阶向量,则矩阵x和向量y可以进行乘法运算,结果为m阶向量.
进行运算时,会首先将后面一项进行自动转置操作,之后再进行乘法运算.样例:
import numpy as npx = np.array([[1, 2, 3],[3, 4, 4]])
y = np.array([1, 2, 3])
result = np.dot(x, y)print(result)
print("x阶数：" + str(x.shape))
print("y阶数：" + str(y.shape))
print("result阶数：" + str(result.shape))结果为:
[14 23]
x阶数：(2, 3)
y阶数：(3,)
result阶数：(2,)
"""

3.np.logical_and()

主要用法: np.logical_and(a, b) .对每个元素进行 and 运算，返回 bool 值组成的数组

如删除数组x中的最大值与最小值:x = x[np.logical_and(x != x.max, x != x.min())]

随机函数

1.np.random.seed()

作用：用于指定随机数生成时所用算法开始的整数值；如果使用相同的seed( )值，则每次生成的随即数都相同；如果不设置这个值，则系统根据时间来自己选择这个值，此时每次生成的随机数因时间差异而不同
注意：设置的seed()值仅一次有效

import numpy as np
np.random.seed(0)
x = np.random.randn(3)
y = np.random.randn(3)
np.random.seed(0)
z = np.random.randn(3)
print(x)  # [1.76405235 0.40015721 0.97873798]
print(y)  # [ 2.2408932   1.86755799 -0.97727788]
print(z)  # [1.76405235 0.40015721 0.97873798]

2.np.random.rand()

作用：创建一个给定类型的数组，将其填充在一个均匀分布的随机样本[0, 1)中

（1）生成单个随机数:          r1=np.random.rand()
（2）生成指定结构的随机数组:
r2=np.random.rand(3)  形如: [ 0.70156865 0.42589945 0.94348143]  #3列
r2=np.random.rand(2,3)
形如: [[ 0.73289586 0.33973611 0.10691378],[ 0.0341497 0.59655438 0.21744271]]  #2行3列np.random.rand(4,3,2) # shape: 4*3*2
# 三维列表,有四个元素,每个元素是二维列表

3.np.random.normal()

作用: normal函数返回一个或一组样本，具有标准正态分布。
np.random.normal(loc= , scale= , size= ) 接收三个参数，normal在这里是指正态分布，该方法通过loc和scale指定正态分布的均值和方差，返回一个数组，内容是从这个分布中随机取得的值，而size就是指定这个数组的大小。np.random.randn() 是 np.random.normal() 在 loc=0, scale=1 时的特例，只用接收 size 一个参数，例如一下两句代码就是等价的：

# 生成100个服从标准正太分布样本点
np.random.randn(100)
data = np.random.normal(size=(1000, 4), loc=0, scale=1)

4.np.random.random()

用于生成指定维度的浮点数，浮点数都是从0-1中随机。

print(np.random.random((2, 3)))[[0.21312921 0.36989348 0.41934852][0.72509954 0.74947924 0.21713272]]

5.np.random.randint()

作用: 返回随机整数，范围区间为[low,high）
参数：low为最小值，high为最大值，size为数组维度大小，dtype为数据类型，默认的数据类型是np.int
high没有填写时，默认生成随机数的范围是[0，low)

np.random.randint(1,size=5) # 返回[0,1)之间的整数，所以只有0
array([0, 0, 0, 0, 0])
np.random.randint(1,10) # 返回1个[1,10)之间的随机整数
np.random.randint(-5,5,size=(2,2))
array([[ 2, -1],[ 2,  0]])

6.np.random.choice()

作用:从一个列表或者数组中,随机进行采样,或者是从指定的区间中进行采样,采样个数可以通过参数设定

data = [4, 65, 25, 13, 46, 79, 46, 26, 34, 66, 46, 63, 98, 78, 21]
ans1 = np.random.choice(data, size=(2, 3))  # 从data中随机采样,生成2行3列的数组
ans2 = np.random.choice(data, 3)  # 从data中随机采样3个数据形成一个一维数组
ans3 = np.random.choice(10, 3)  # 从0~10之间随机取三个数

np.arange()

语法结构: np.arange([start, ]stop, [step, ]dtype=None)
生成的是等差数组

start:可忽略不写，默认从0开始;起始值
stop:结束值；生成的元素不包括结束值
step:可忽略不写，默认步长为1；
dtype:默认为None，设置显示元素的数据类型import numpy as np
nd1 = np.arange(5)      #array([0, 1, 2, 3, 4])
nd2 = np.arange(1,5)    #array([1, 2, 3, 4])
nd3 = np.arange(1,5,2)  #array([1, 3])b = np.arange(10) ** 2  # b = [ 0  1  4  9 16 25 36 49 64 81]

np.apply_along_axis()

作用: 沿着某个轴执行指定的函数

# 求数组a按行求均值,并且要去掉最大值与最小值
# np.apply_along_axis(lambda x:x[(x !=x.max()) & (x !=x.min())].mean,axis=1,arr=a)a = np.random.randint(60, 100, size=(4, 20))def func(x):y = x[np.logical_and(x != x.max, x != x.min())].mean()print(y)print("=" * 30)np.apply_along_axis(func, axis=1, arr=a)  # 函数不需要加括号

np.cumsum()

作用: 这个函数的功能是返回给定axis上的累计和

1.对于一维输入a（可以是list，可以是array，假设a=[1, 2, 3, 4, 5, 6, 7] ，就是当前列之前的和加到当前列上，如下：


import numpy as np
a=[1,2,3,4,5,6,7]
print(np.cumsum(a))
array([  1,   3,   6,  10,  15,  21,  28])

2.对于二维输入a，axis=0(第1行不动，将第1行累加到其他行)；axis=1(进入最内层，转化成列处理。第1列不动，将第1列累加到其他列)

np.reshape()

作用: 给数组一个新的形状而不改变原数组形状（resize()函数便会改变原数组形状）
注意: 通过reshape生成的新数组其形状变化的原则是数组元素不能发生改变（维度乘积必须等于元素个数）

nd2.reshape(2,2)#array([[1, 2], [3, 4]])
注意：对数组重塑后的元素个数不能大于原来本身的元素个数，不然会报错
比如说，nd2生成了四个元素，你要重塑（2,3）就是六个元素，会报错的转换为一维数组 nd2.reshape(4,) 或者 nd2.flatten()

np.zeros()

语法结构: numpy.zeros（shape, dtype=float, order='C）
返回：返回一个给定形状和类型的用0填充的数组；
参数：shape:形状; dtype:数据类型，可选参数，默认numpy.float64
order:可选参数，c代表与c语言类似，行优先；F代表列优先
numpy.ones()用法一致
numpy.full((2,3),9)生成2行3列元素为9的数组

np.zeros(5, dtype=np.int)
array([0, 0, 0, 0, 0])

np.pad()

应用: 在卷积神经网络中，为了避免因为卷积运算导致输出图像缩小和图像边缘信息丢失，常常采用图像边缘填充技术，即在图像四周边缘填充0，使得卷积运算后图像大小不会缩小，同时也不会丢失边缘和角落的信息。在Python的numpy库中，常常采用numpy.pad()进行填充操作

语法结构: np.pad(array, pad_width, mode, **kwargs)
返回值：数组

参数	说明
array	表示需要填充的数组
pad_width	表示每个轴（axis）边缘需要填充的数值数目。
mode	表示填充的方式（取值：str字符串或用户提供的函数）,总共有11种填充模式

填充方式	说明
‘constant’	表示连续填充相同的值，每个轴可以分别指定填充值，constant_values=（x, y）时前面用x填充，后面用y填充，缺省值填充0
‘edge’	表示用边缘值填充
‘linear_ramp’	表示用边缘递减的方式填充
‘maximum’	表示最大值填充
‘mean’	表示均值填充
‘median’	表示中位数填充
‘minimum’	表示最小值填充
‘reflect’	表示对称填充
‘symmetric’	表示对称填充
‘wrap’	表示用原数组后面的值填充前面，前面的值填充后面

"""
pad_width——表示每个轴（axis）边缘需要填充的数值数目。
参数输入方式为：（(before_1, after_1), … (before_N, after_N)）
其中(before_1, after_1)表示第1轴两边缘分别填充before_1个和after_1个数值.取值为：{sequence, array_like, int}
#在二维数组A的边缘填充constant_values指定的数值
#（3,2）表示在axis = 0轴填充
#（2,3）表示在axis = 1轴填充
"""a = np.arange(95, 99).reshape(2, 2)  # 原始输入数组b = np.pad(a, pad_width=1)
print(b)# constant_values表示填充值，且(before，after)的填充值等于（0,0）
c = np.pad(a, ((3, 2), (2, 3)), 'constant', constant_values=(0, 0))
print(c)# 0轴和1轴分别填充不同的值，先填充0轴，后填充1轴，存在1轴填充覆盖0轴填充的情形
d = np.pad(a, ((3, 2), (2, 3)), 'constant', constant_values=((0, 0), (1, 2)))
print(d)

np.sort()

np.sort:指定轴进行排序,默认是使用数组的最后一个轴进行排序.默认是升序排序，并不会影响原数组本身
ndarray.sort() ,这个方法会直接影响到原来的数组,而不是返回一个新的排序后的数组
倒序排序：-np.sort(-a)
更直接的a = a[::-1]

np.sum()

1.sum(a)默认为对输入参数中的所有元素进行求和

# 目标函数
def E(x, y):# y, f(x)均为列表return 0.5 * np.sum((y - f(x)) ** 2)

2.sum()输入参数带有axis时，将按照指定axis进行对应求和

b = np.arange(12).reshape(2, 6)# 此处要充分理解维度和坐标的关系，理解它是怎么运算的
print(np.sum(b))  # 对b中元素求和
print(np.sum(b, axis=0))  # 对b的每一列求和
print(np.sum(b, axis=1))  # 对b的每一行求和

np.linalg.eig(arr)

作用: 计算矩阵特征值，特征向量。函数返回特征值和特征向量


# 给出判断矩阵
arr = np.array([[1, 2, 5], [1 / 2, 1, 2], [1 / 5, 1 / 2, 1]])# 矩阵的特征值和特征向量(均为实数)
eig_val, eig_vector = np.linalg.eig(arr)print(eig_val)
print('='*30)
print(eig_vector)
print('='*30)# 矩阵的最大特征值
max_eig_val = np.max(eig_val)# 矩阵最大特征值对应的特征向量(只要实部)
max_eig_vector = eig_vector[:, np.argmax(eig_val)].real
print(max_eig_vector)"""
结果:
特征值:
[ 3.00553511e+00+0.j         -2.76755587e-03+0.12895082j-2.76755587e-03-0.12895082j]
==============================
[[-0.89021421+0.j         -0.89021421+0.j         -0.89021421-0.j        ][-0.41320083+0.j          0.20660042+0.35784242j  0.20660042-0.35784242j][-0.19179084+0.j          0.09589542-0.16609574j  0.09589542+0.16609574j]]
==============================
(3.0055351117384994+0j)
==============================
[-0.89021421 -0.41320083 -0.19179084]
=============================="""

np.unique()

作用:返回数组中的唯一值.
返回数组a中的唯一值,并且会返回每个唯一值出现的次数
np.unique(a,return_counts=True)

a = np.random.randint(60, 100, size=(3, 10))
a = np.unique(a, return_counts=True)
print(a)

np.where()

1. np.where(condition, x, y)
满足条件(condition)，输出x，否则输出y。

b = np.arange(10)print(np.where(b, 1, -1))
# 输出   [-1  1  1  1  1  1  1  1  1  1]
print(np.where(b > 5, 1, -1))
# 输出   [-1 -1 -1 -1 -1 -1  1  1  1  1]
# help(np.where)

2. np.where(condition)
只有条件 (condition)，没有x和y，则输出满足条件 (即非0) 元素的坐标 (等价于numpy.nonzero)。这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标。

np.linspace()

通过定义均匀间隔创建数值序列。

num 参数控制结果中共有多少个元素。缺省为50.
endpoint = True, 结果中包括终止值，反之不包括。缺省为True。b = np.linspace(start=1, stop=10, num=4, endpoint=False, dtype=np.int)

np.transpose()

对于二维 ndarray，transpose在不指定参数时默认是矩阵转置。

不妨设第一个方括号“[]”为 0轴 ，第二个方括号为 1轴
则 x.transpose((0,1)) 表示按照原坐标轴改变序列，也就是保持不变
而 x.transpose((1,0)) 表示交换 ‘0轴’ 和 ‘1轴’

np.flatten()和numpy.ravel()

首先两者所要实现的功能是一致的（将多维数组降位一维）。两者的区别在于返回拷贝（copy）还是返回视图（view），numpy.flatten()返回一份拷贝（深拷贝a.copy()），对拷贝所做的修改不会影响（reflects）原始矩阵，而numpy.ravel()返回的是视图（view，浅拷贝），会影响（reflects）原始矩阵。

np.max(),np.argmax(),np.maximum()

"""
a = np.arange(1, 21).reshape(4, 5)
# 求数组的最大值
b1 = np.max(a)# 行:axis=1; 列:axis=0
# 求每一列的最大值
b2 = np.max(a, axis=0)
# 求每一行的最大值
b3 = np.max(a, axis=1)np.argmax()与np.max()类似：np.max()返回指定轴的最大值，而np.argmax()返回指定轴的最大值对应的索引
np.maximum()
np.maximum(array1, array2)：逐位比较array1和array2，并输出两者的最大值。如果array1和array2的形状相同，则输出结果的形状与array1和array2的形状相同。
如果array1和array2的形状不同（允许只有一个维度不同），则会用到numpy的broadcast机制。
如果用于比较的ndarray有一个是标量，则另一个ndarray可以是任何形状，这同样用到了broadcast机制"""

np.vstack()和np.hstack()

hstack(tup) ，参数tup可以是元组，列表，或者numpy数组，返回结果为numpy的数组。水平(按列顺序)把数组给堆叠起来 vstack()函数正好和它相反。它是垂直（按照行顺序）的把数组给堆叠起来。

import numpy as np
a=[1,2,3]
b=[4,5,6]
print(np.hstack((a,b)))
输出：[1 2 3 4 5 6 ]
print(np.vstack((a,b)))
输出：[[1 2 3],[4 5 6]]a=[[1],[2],[3]]
b=[[1],[2],[3]]
c=[[1],[2],[3]]
d=[[1],[2],[3]]
print(np.hstack((a,b,c,d)))
输出：[[1 1 1 1],[2 2 2 2],[3 3 3 3]]

np.c_()和np.r_()

np.r_是按列连接两个矩阵，就是把两矩阵上下相加，要求列数相等。
np.c_是按行连接两个矩阵，就是把两矩阵左右相加，要求行数相等。

np.mean()，np.var(),np.std()

mean()函数的功能是求取平均值，经常操作的参数是axis，以m*n的矩阵为例：
axis不设置值，对m*n个数求平均值，返回一个实数
axis = 0：压缩行，对各列求均值，返回1*n的矩阵
axis = 1: 压缩列，对各行求均值，返回m*1的矩阵

np.std()是用来计算标准差，默认是总体标准差，若需要得到样本标准差，需要跟参数 ddof =1；np.var()是用来计算方差，默认是总体方差（计算时除以样本数 N），若需要得到样本方差（计算时除以 N - 1），需要跟参数 ddof= 1

补充：numpy 中的 average 方法不仅能求得简单平均数，也可以求出加权平均数。average 里面可以跟一个 weights 参数，里面是一个权数的数组。

b = np.arange(1, 5)
print(np.average(b))# weights维度与b一致
print(np.average(b, weights=[1, 2, 1, 1]))

np.polyfit()和np.poly1d()

两者结合使用可以得到多项式拟合函数。前者得到多项式的各项系数，后者将系数与未知量相结合得到表达式，进而可以求得函数值

Pandas

文件操作

pd.read_excel()

参考博客

计算均值、方差、标准差

df = pd.DataFrame(np.array([[85, 68, 90], [82, 63, 88], [84, 90, 78]]), columns=['统计学', '高数', '英语'],index=['张三', '李四', '王五'])
print(df)
print(df.mean())  # 显示每一列的平均数
print(df.mean(axis=1))  # 显示每一行的平均数若要得到某一行或某一列的平均值，则可以使用 iloc 选取该行或该列数据，后面跟 mean 函数就能得到，例如：
print(df.iloc[0, :].mean())  # 得到第 1 行的平均值
print(df.iloc[:, 2].mean())  # 得到第 3 列的平均值

pandas 中的 var 函数可以得到样本方差（注意不是总体方差），std 函数可以得到样本标准差，若要得到某一行或某一列的方差，则也可用 iloc 选取某行或某列，后面再跟 var 函数或 std 函数即可

pd.concat()

参考博客
作用: 可以将数据根据不同的轴作简单的融合

pd.concat(objs, axis=0, join=‘outer’, join_axes=None, ignore_index=False,
keys=None, levels=None, names=None, verify_integrity=False)

参数	说明
objs	series，dataframe或者是panel构成的序列lsit
axis	需要合并链接的轴，0是行，1是列
join	连接的方式 inner，或者outer

其他一些参数不常用，用的时候再补上说明。

# 1.1 相同字段的表首尾相接
# 现将表构成list，然后在作为concat的输入
In [4]: frames = [df1, df2, df3]
In [5]: result = pd.concat(frames)# 要在相接的时候在加上一个层次的key来识别数据源自于哪张表，可以增加key参数
In [6]: result = pd.concat(frames, keys=['x', 'y', 'z'])# 1.2 横向表拼接（行对齐）
# 当axis = 1的时候，concat就是行对齐，然后将不同列名称的两张表合并
In [9]: result = pd.concat([df1, df4], axis=1)# 1.2.2 join
# 加上join参数的属性，如果为’inner’得到的是两表的交集，如果是outer，得到的是两表的并集。
In [10]: result = pd.concat([df1, df4], axis=1, join='inner')

pd.date_range()

pd.date_range(start=None, end=None, periods=None, freq=None, tz=None, normalize=False,
name=None, closed=None, kwargs）

参数	说明
start	这个参数是时间索引的起始时间
end	自然这个参数是结束的时间
period	如果你只使用了起始或结束的时间戳，那么就需要使用period来告知一个范围
freq	这个是frequency的缩写，也就是频率，这个是一个非常重要的参数，可以通过设置这个参数得到自定义的时间频率

 index = pd.date_range('1/1/2000', periods=9, freq='T')series = pd.Series(range(9), index=index)# B = Business day 也就是工作日，可以看到第一个的输出结果就是显示的就是从明天开始的5个工作日。
pd.date_range(start=datetime.now(), periods=5, freq='B')

pd.merge()

作用: 是用数据库样式的连接合并DataFrame或者已命名的Series。
pd.merge()只能用于两个表的左右拼接。

如果需要拼接的两个表中，有相同的列信息，那么进行拼接的时候即使不指定以哪个字段作为主键
函数也会默认用信息相同的列做主键对两个表进行拼接。
参考博客一
参考博客二

on 确定哪个字段作为主键,如果有相同的列信息
不指定主键也可以参数leftindex和rightindex
除了指定字段作为主键以外，还可以考虑用索引作为拼接的主键，
leftindex和rightindex默认为False，就是不以索引作为主键，调整为True就可以了。参数how
how参数控制拼接方式，默认内连接（inner），那么不同的拼接方式对结果有怎样的影响呢，
内连接是只将两个表主键一致的信息拼接到一起，上边的例子已经演示过，下边来看一下外连接。外连接是保留两个表的所有信息，拼接的时候遇到标签不能对齐的部分，用NAN进行填充data_all = pd.merge(data, data_index, how="outer")

pd.pivot_table()

对数据做透视，简单的例子就是数据中2019年淘宝销量有重复的统计了，该函数可以将其相加合并起来

直接看参考博客吧，人家讲的很细了

pd.to_datetime()

作用: 通过pd.read_csv()或者pd.read_excel()读取文件过后，得到的数据列对应的类型是“object”，这样没法对时间数据处理，可以通过pd.to_datetime将该列数据转换为时间类型，即datetime。
转换过后就可以对这些时间数据操作了，可以相减求时间差，计算相差的秒数和天数，调用的方法和datetime库的方法一致，分别是 data.dt.days() 、data.dt.seconds() 、data.dt.total_seconds()。

pd.to_datetime（arg，errors =‘raise’，utc = None，format = None，unit = None ）

参数	说明
errors	三种取值，‘ignore’, ‘raise’, ‘coerce’，默认为raise。
	‘raise’，则无效的解析将引发异常 ,
	‘coerce’，那么无效解析将被设置为NaT,
	‘ignore’，那么无效的解析将返回输入值.
utc	布尔值，默认为none。返回utc即协调世界时。
format	格式化显示时间的格式。
unit	默认值为‘ns’，则将会精确到微妙，‘s’为秒。

# 将data的所有时间转换为时间戳
# x.timetuple()将时间转换为时间元组，提前导入time模块
data = data.apply(lambda x:time.mktime(x.timetuple()))# 将data的所有时间轴转换为可读时间：
data = data.apply(lambda x:time.strftime('%Y/%m/%d %H:%M:%S',time.localtime(x)))
#代码含义为：先读取时间轴数据，将其转换为时间元组，在通过格式化时间转换为可读的时间格式data_all['采集时间'] = to_datetime(data_all.采集时间, format='%Y/%m/%d %H:%M:%S')

pd.Series()

"""
Series
Series是一种一维标记的数组型对象,能够保存任何数据类型(str,int float...),
包含了数据标签,称为索引1.类似一维数组的对象,index=['名字', '年龄', '班级']
2.由数据和索引组成索引(index)在左,数据(values)在右索引是自动创建的
"""
# 1.通过list列表创建(索引长度和数据长度必须相同)
s1 = pd.Series([1, 2, 3, 4, 5, 6])# 2.通过数组创建(索引长度和数据长度必须相同)
arr1 = np.arange(1, 6)
s2 = pd.Series(arr1, index=['a', 'b', 'c', 'd', 'e'])
# print(s2.values)# 3.通过字典创建(索引长度和数据长度可以不同,不同填空NAN)
dict3 = {'name': '李宁', 'age': 18, 'class': '一班'}
s3 = pd.Series(dict3, index=['name', 'age', 'class', 'sex'])
print(s3)# 导入string库实现用大写字母作索引值
a = {string.ascii_uppercase[i]: i for i in range(10)}
b = pd.Series(a)
print(b)
"""
3.1   isnull 和 notnull 检查缺失值isnull 判断是否为空  空就是Truenotnull 判断是否不为空  非空就是True3.2   通过索引获取数据print(s3.index)  # s3.index是迭代器可以被迭代print(s3.values)# 下标print(s3[0]) # print(s3[1,3]) 可以选取多个但返回的还是Series# 标签名print(s3['age'])# 下标切片(左闭右开)s3[1:3] # 取 1,2# 标签切片(左闭右闭)s3['name':'class']# bool索引s2[s2>3]
3.3   索引与数据的对应关系不被运算结果影响
3.4   name属性s2.name = 'temp' # 对象名s2.index.name = 'year' # 对象索引名
"""

pd.DataFrame() 参考博客

DataFrame的单元格可以存放数值、字符串等，这和excel表很像，同时DataFrame可以设置列名columns与行名index。

"""
DataFrame是一个表格型的数据结构,它含有一组有序的列,每列可以是不同类型的值.
DataFrame既有行索引又有列索引,它可以被看做是由Series组成的字典(公用同一个索引),数据是以二维结构存放的
1. 类似多维数组/表格数据(如 excel)
2. 每列数据可以是不同的类型
3. 索引包括行索引和列索引
"""
import string
import numpy as np
import pandas as pda = np.arange(10, 60).reshape(10, 5)
b = list(string.ascii_lowercase[:10])
c = list(string.ascii_uppercase[:5])df = pd.DataFrame(a, columns=c, index=b)"""
1.df.loc 通过标签索引行数据
2.df.iloc 通过位置索引行数据
"""
# 选择某一列前几行
print(df[:5]['A'])# 选择间隔的多行多列
print(df.loc[['a', 'c', 'e'], ['A', 'C']])# 冒号在loc里面是闭合的
print(df.iloc[:5, [1, 2, 4]])"""
DataFrame的基础属性
df.shape     # 行数 列数
df.dtypes    # 列数据类型
df.ndim      # 数据维度
df.index     # 行索引
df.columns   # 列索引
df.values    # 对象值, 二维ndarray数组DataFrame整体情况查询
df.head()    # 显示头部几行, 默认5行
df.tail()    # 显示末尾几行, 默认5行df.info()    # 相关信息概览: 行数, 列数, 列索引, 列非空值个数, 列类型, 内存占用
df.describe()# 快速综合统计结果: 计数, 均值, 标准差, 最大值, 最小值
"""

df.join()

参考博客
dataframe内置的join方法是一种快速合并的方法。它默认以index作为对齐的。

df.query()

"""
DataFrame.query(expr, inplace=False, **kwargs)1、常规操作
要从一个 dataframe 中,筛选出某些列值符合要求的行数据,可以用类似以下的语句实现:
df[df[col] == x]
也可以用 .query() 实现: df.query('col == x')2、其他操作方法1) 筛选出 col 列中值不是 bool 类型的行:
df.query('col not in (True, False)')2) 筛选出 col 列中值为 nan、None 的值:
df = pd.DataFrame({"value": [3,4,9,10,11,np.nan,12]})# 方法1
# 利用 'nan 不等于自身' 的性质，筛选出非 nan、None 的行
df.query("value == value')# 方法2
# 类似的还有 isnull, notnull,isnan 等
df.query('value.notna()', engine='python')# 方法3
df.query('value != 'NaN'")
"""

df.dropna()

df.dropna()函数用于删除dataframe数据中的缺失数据，即删除NaN数据.

参数	说明
axis	0为行 1为列，default 0，数据删除维度
how	{‘any’, ‘all’}, default ‘any’，any：删除带有nan的行；all：删除全为nan的行
thresh	int，保留至少 int 个非nan行
subset	list，在特定列缺失值处理
inplace	bool，是否修改源文件

"""
删除至少缺少一个元素的行： df.dropna()
删除至少缺少一个元素的列： df.dropna(axis=1)
删除所有元素丢失的行：    df.dropna(how='all')
只保留至少2个非NA值的行： df.dropna(thresh=2)
修改原数据：            df.dropna(inplace=True)
从特定列中查找缺少的值：  df.dropna(subset=['name', 'born'])
"""

补充: pandas 处理缺失值[dropna、drop、fillna]
dropna：去掉含有缺失值的样本（行）
drop：将含有缺失值的列（特征向量）去掉
fillna：将缺失值用某些值填充（0，平均值(mean)，中值(median)等)

df.groupby()

作用：groupby函数主要的作用是进行数据的分组以及分组后地组内运算。
具体函数的规则如下：：df.groupby([df[属性],df[属性])(指分类的属性，数据的限定定语，可以有多个).mean()(对于数据的计算方式——函数名称)
举例如下：
print(df[“评分”].groupby([df[“地区”],df[“类型”]]).mean())
上面语句的功能是输出表格所有数据中不同地区不同类型的评分数据平均值

# 各水表总用水量统计
# 根据水表号进行分组,分别统计各水表的用水总量
sbm_sl = data_all['用量'].groupby(by=data_all['水表号']).sum()# 12个工作区总用水量
# 根据功能进行分组,分别统计不同功能区的用水总量
gnq_sl = data_all['用量'].groupby(by=data_all['功能分类']).sum()"""
count       # 分组中非NA值的数量
sum         # 非NA值的和
mean        # 非NA值的平均值
median      # 非NA值的算数中位数
std,var     # 无偏（分母为n-1）标准差和方差
min,max     # 非NA值的最小值和最大值
"""
如果需要对国家和省份进行分组统计,则可以为:grouped = df.groupby(by = [df['Country'],df['State/Province']])# 需要对字符串切割后获得分组的
temp_list = df['title'].str.split(":").tolist()
cate_list = list(set([i[0] for i in temp_list]))

df.resample()

参考博客
作用：重新采样，是对原样本重新处理的一个方法，是一个对常规时间序列数据重新采样和频率转换的便捷的方法。
降采样：高频数据到低频数据
升采样：低频数据到高频数据

resample方法的参数

参数	说明
freq	表示重采样频率，例如‘M’、‘5min’，Second(15)
how=’mean’	用于产生聚合值的函数名或数组函数，例如‘mean’、‘ohlc’、np.max等，默认是‘mean’，其他常用的值由：‘first’、‘last’、‘median’、‘max’、‘min’
axis=0	默认是纵轴，横轴设置axis=1
fill_method = None	升采样时如何插值，比如‘ffill’、‘bfill’等
closed = ‘right’	在降采样时，各时间段的哪一段是闭合的，‘right’或‘left’，默认‘right’
label= ‘right’	在降采样时，如何设置聚合值的标签，例如，9：30-9：35会被标记成9：30还是9：35,默认9：35
loffset = None	面元标签的时间校正值，比如‘-1s’或Second(-1)用于将聚合标签调早1秒
limit=None	在向前或向后填充时，允许填充的最大时期数
kind = None	聚合到时期（‘period’）或时间戳（‘timestamp’），默认聚合到时间序列的索引类型
convention = None	当重采样时期时，将低频率转换到高频率所采用的约定（start或end）。默认‘end’


# 建模国赛2020E题核心代码部分temp.set_index('采集时间', inplace=True)gnq_day.iloc[:, i] = temp['用量'].resample('D').sum()"""df['time'] = pd.to_datetime(df['time'])
df.set_index('time', inplace = True)# 统计出911数据中不同月份电话的次数
count_by_month = df.resample('M').count()['title']  # 此时为Series# 画图
_x = count_by_month.index
_y = count_by_month.values# 通过strftime函数格式化时间序列
_x = [i.strftime(%Y/%m/%d) for i in _x]plt.figure(figsize=(20,8), dpi = 80)plt.plot(range(len(_x)), y)
plt.xticks(range(len(_x)), _x, rotation=45)
plt.show()"""

df.sort_values()

作用：既可以根据列数据，也可根据行数据排序。

方法的参数

参数	说明
by	指定列名(axis=0或’index’)或索引值(axis=1或’columns’)
axis	若axis=0或’index’，则按照指定列中数据大小排序；若axis=1或’columns’，则按照指定索引中数据大小排序，默认axis=0
ascending	是否按指定列的数组升序排列，默认为True，即升序排列
inplace	是否用排序后的数据集替换原来的数据，默认为False，即不替换
na_position	{‘first’,‘last’}，设定缺失值的显示位置
kind	排序方法，{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。


a = np.arange(10, 60).reshape(10, 5)
b = list(string.ascii_lowercase[:10])
c = list(string.ascii_uppercase[:5])df = pd.DataFrame(a, columns=c, index=b)d = df.sort_values(by=['A'], ascending=False)
print(d)

Matplotlib

案例一

import matplotlib.pyplot as plt# 显示中文（因为横纵坐标想要显示中文的）
plt.rcParams['font.sans-serif'] = ['SimHei']x = range(11, 31)
y_1 = [1, 0, 1, 1, 2, 4, 3, 2, 3, 4, 4, 5, 6, 5, 4, 3, 3, 1, 1, 1]
y_2 = [1, 0, 3, 1, 2, 2, 3, 3, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1]plt.figure(figsize=(10, 10), dpi=100)  # 设置图片大小 dpi的设置可以让图片更加清晰plt.plot(x, y_1, label="自己", color="red", linestyle=':', linewidth=2)  # alpha设置透明度
plt.plot(x, y_2, label="同桌", color="black", linestyle='--', linewidth=2)
"""
plt.scatter()  # 绘制散点图
plt.bar(len(x),y) # 绘制条形图
"""
_x = ["{}岁".format(i) for i in x]
plt.xticks(x, _x, color='blue', rotation=60)
plt.yticks(range(0, 9))# 绘制网格图
plt.grid(alpha=0.4)  # alpha 设置透明度# 添加图例 plot要添加label
plt.legend(loc=2)  # 参数改变显示位置plt.xlabel("年龄")
plt.ylabel("女朋友数")
# plt.savefig("./sig_size.svg")  # 保存图片
plt.show()

案例二

from mpl_toolkits.mplot3d import Axes3D
# 绘制3D图
fig = plt.figure(figsize=(12, 8))
ax = Axes3D(fig)delta = 0.25
# 生成代表X轴数据的列表
X = np.arange(-4, 4, delta)
# 生成代表Y轴数据的列表
Y = np.arange(-4, 4, delta)
# 对x、y数据执行网格化
X, Y = np.meshgrid(X, Y)R = np.sqrt(X ** 2 + Y ** 2)
Z = np.sin(R)'''
rstride（row）指定行的跨度
cstride(column)指定列的跨度
cmap=plt.get_cmap('rainbow'))  # 设置颜色映射
cmap=plt.cm.coolwarm冷图
cmap=plt.cm.hot 热力图# 设置Z轴范围
ax.set_zlim(-2, 2)
# 设置标题
plt.title("3D图")
fig.colorbar(surf, shrink=0.5, aspect=5)
ax.set_xlabel('x')
'''
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=plt.get_cmap('rainbow'))
plt.show()

案例三

# 绘制等高线图
def f(x, y): return (1 - x / 2 + x ** 5 + y ** 3) * np.exp(-x ** 2 - y ** 2)n = 256
x = np.linspace(-3, 3, n)
y = np.linspace(-3, 3, n)
# 把x,y数据生成mesh网格状的数据，因为等高线的显示是在网格的基础上添加上高度值
X, Y = np.meshgrid(x, y)  # 生成网格点坐标矩阵# 填充等高线 "8"数字刻画等高线的密集程度，数字越大越密集
plt.contourf(X, Y, f(X, Y), 8, alpha=.75, cmap='jet')
# 添加等高线
C = plt.contour(X, Y, f(X, Y), 8, colors='black', linewidth=.5)
plt.clabel(C, inline=True, fontsize=12)
plt.show()

案例四

plt.figure(figsize=(20, 8), dpi=80)
time =[131,  98, 125, 131, 124, 139, 131, 117, 128, 108, 135, 138, 131, 102, 107, 114, 119, 128, 121, 142, 127, 130, 124, 101, 110, 116, 117, 110, 128, 128, 115,  99, 136, 126, 134,  95, 138, 117, 111,78, 132, 124, 113, 150, 110, 117,  86,  95, 144, 105, 126, 130,126, 130, 126, 116, 123, 106, 112, 138, 123,  86, 101,  99, 136,123, 117, 119, 105, 137, 123, 128, 125, 104, 109, 134, 125, 127,105, 120, 107, 129, 116, 108, 132, 103, 136, 118, 102, 120, 114,105, 115, 132, 145, 119, 121, 112, 139, 125, 138, 109, 132, 134,156, 106, 117, 127, 144, 139, 139, 119, 140,  83, 110, 102,123,107, 143, 115, 136, 118, 139, 123, 112, 118, 125, 109, 119, 133,112, 114, 122, 109, 106, 123, 116, 131, 127, 115, 118, 112, 135,115, 146, 137, 116, 103, 144,  83, 123, 111, 110, 111, 100, 154,136, 100, 118, 119, 133, 134, 106, 129, 126, 110, 111, 109, 141,120, 117, 106, 149, 122, 122, 110, 118, 127, 121, 114, 125, 126,114, 140, 103, 130, 141, 117, 106, 114, 121, 114, 133, 137,  92,121, 112, 146,  97, 137, 105,  98, 117, 112,  81,  97, 139, 113,134, 106, 144, 110, 137, 137, 111, 104, 117, 100, 111, 101, 110,105, 129, 137, 112, 120, 113, 133, 112,  83,  94, 146, 133, 101,131, 116, 111,  84, 137, 115, 122, 106, 144, 109, 123, 116, 111,111, 133, 150]
bins = 2group = int((max(time) - min(time)) / bins)# plt.hist(time, group, normed=1)
plt.hist(time, group)# 指定刻度的范围以及时长
plt.xticks(list(range(min(time), max(time)))[::2]) #  步长为2
plt.xlabel("电影时长大小")
plt.ylabel("电影的数据量")# 表格中的网状线
plt.grid(True, linestyle='--', alpha=0.8)
plt.show()

案例五

参考博客一
参考博客二

import matplotlib.pyplot as pltname_list = ['Monday', 'Tuesday', 'Friday', 'Sunday']
num_list = [1.5, 0.6, 7.8, 6]
num_list1 = [1, 2, 3, 1]
x = list(range(len(num_list))) #  range对int型 list 可将float型转为int型
total_width, n = 0.8, 2
width = total_width / nplt.bar(x, num_list, width=width, label='boy', fc='y')
for i in range(len(x)):x[i] = x[i] + width
plt.bar(x, num_list1, width=width, label='girl', tick_label=name_list, fc='r')
plt.legend()
plt.show()# 绘制条形柱状图
language = ['Python', 'C++', 'Java', 'Perl', 'Scala', 'Lisp']x_pos = range(len(language))pop = [10, 8, 6, 4, 2, 1]
plt.barh(x_pos, pop, align='center', alpha=0.5)
plt.yticks(x_pos, language)
plt.xlabel('Popularity')
plt.title('Programming Language Popularity')
plt.show()

案例六

import matplotlib.pyplot as plt
import matplotlibmatplotlib.rcParams['font.sans-serif'] = ['SimHei']
matplotlib.rcParams['axes.unicode_minus'] = Falselabel_list = ["第一部分", "第二部分", "第三部分"]    # 各部分标签
size = [55, 35, 10]    # 各部分大小
color = ["r", "g", "b"]     # 各部分颜色
explode = [0.05, 0, 0]   # 各部分突出值"""
绘制饼图
explode：设置各部分突出
label:设置各部分标签
labeldistance:设置标签文本距圆心位置，1.1表示1.1倍半径
autopct：设置圆里面文本
shadow：设置是否有阴影
startangle：起始角度，默认从0开始逆时针转
pctdistance：设置圆内文本距圆心距离
返回值
l_text：圆内部文本，matplotlib.text.Text object
p_text：圆外部文本
"""patches, l_text, p_text = plt.pie(size, explode=explode, colors=color, labels=label_list, labeldistance=1.1, autopct="%1.1f%%", shadow=True, startangle=90, pctdistance=0.6)
plt.axis("equal")    # 设置横轴和纵轴大小相等，这样饼才是圆的
plt.title("饼状图")
plt.legend()
plt.show()

plt.xticks()

xticks(ticks, [labels], **kwargs)
参数说明：
ticks：数组类型，用于设置X轴刻度间隔
[labels]：数组类型，用于设置每个间隔的显示标签
kwargs：用于设置标签字体倾斜度和颜色等外观属性.
ticks 与[labels]存在一对一映射关系

x = range(1,13,1)
y = range(1,13,1)
plt.plot(x,y)
plt.xticks(x, calendar.month_name[1:13],color='blue',rotation=60)  #参数x空值X轴的间隔，第二个参数控制每个间隔显示的文本，后面两个参数控制标签的颜色和旋转角度
plt.show()

plt.contourf()和plt.contour()

参考博客

是来绘制等高线的，contour和contourf都是画三维等高线图的，不同点在于contour() 是绘制轮廓线，contourf()会填充轮廓。除非另有说明，否则两个版本的函数是相同的。
注意 : 要画出等高线，核心函数是plt.contourf()，但在这个函数中输入的参数是x,y对应的网格数据以及此网格对应的高度值，因此我们调用np.meshgrid(x,y)把x,y值转换成网格数据.

plt.clabel()

参考博客

等高线图或水平图是在二维平面上显示三维表面的一种方式。它以轮廓图的形式在y轴上作为一个输出变量z和两个预测变量x和y。通常，此类轮廓也称为z-slices。
mathplotlib.pyplot中的clabel()方法用于在类的实例中为线轮廓添加标签，以支持轮廓绘制。

plt.annotate()用于标注文字

参考博客一
参考博客二

plt.annotate('我是注释', xy=(0, 1), xytext=(1, 0.5),arrowprops=dict(facecolor='black', shrink=0.01),)x = np.arange(0, 6)
y = x * xplt.plot(x, y, marker='o')
for xy in zip(x, y):plt.annotate("(%s,%s)" % xy, xy=xy, xytext=(-20, 10), textcoords='offset points',bbox=dict(boxstyle='round,pad=0.5', fc='yellow', ec='k', lw=1, alpha=0.5))
plt.show()

plt.hist()

参考博客

"""
绘制直方图
data:必选参数，绘图数据
bins:直方图的长条形数目，可选项，默认为10
normed:是否将得到的直方图向量归一化，可选项，默认为0，代表不归一化，显示频数。normed=1，表示归一化，显示频率。
facecolor:长条形的颜色
edgecolor:长条形边框的颜色
alpha:透明度plt.hist(data, bins=40, facecolor="blue", edgecolor="black", alpha=0.7)
"""

plt.bar()

参考博客

plt.bar(x, height, width, bottom, tick_label, label, **kwargs)

其他

# 删除某一个特征数据，返回删除后的列表
def splitDataSet(dataSet, axis, value):  # 按某个特征分类后的数据 axis 对应的是特征的索引retDataSet = []  # 属于同一属性相同特征值的放在一个列表中for featureVec in dataSet:if featureVec[axis] == value:  # 如果相同reducedFeatureVec = featureVec[:axis]  # 取其前面的元素 和 其后面的元素放入同一个列表中reducedFeatureVec.extend(featureVec[axis + 1:])  # extend 在一个列表的末尾一次性追加一列表retDataSet.append(reducedFeatureVec)return retDataSet  # 此时retDataSet已是一个二维列表 len（retDataSet）就表示 特征i的所有取值中 == value 的有多少个 （分类）# 二维列表中，抽取每一列的数据
for i in range(len(dataSet)):# 获取当前特征i的所有可能取值# 此处意思是遍历dataSet的每一个子元素列表,取出特定位置的元素组成新列表List = [example[i] for example in dataSet]  # example每次取的是dataSet的子列表# 字典排序
# 字典 items() 方法以列表返回可遍历的(键, 值) 元组数组. reverse = True 降序， reverse = False 升序（默认）
# itemgetter 用于获取对象的哪些位置的数据，参数即为代表位置的序号值 字典中 key 下标可认为是 0 value 为 1sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True) #按value值降序排序return sortedClassCount[0][0]  #返回最大值

数据加载方式

# 加载数据 数据以逗号间隔，整型读入，读入所有行
dataset = np.loadtxt('data\watermelon_3a.csv', delimiter=',', skiprows=0) # 注意此处是"\"dataset = np.loadtxt(open("./data/watermelon_3a.csv","rb"),delimiter=",",skiprows=0)  # 注意此处是"/"# 用pandas加载数据
dataset = pd.read_csv('predata/task1_data.csv') # 注意此处是"/"
# 输出到指定文件
dataset.to_csv("predata/task_data.csv", index=False)# 定义函数加载数据
def loaddata_new():# 定义文件路径csv_path = '../../算法模型/决策树原理/data\data.csv' # 找到文件路径with open(csv_path, 'r', encoding='utf-8-sig')as fp:dataSet = [i for i in csv.reader(fp)]  # csv.reader 读取到的数据是list类型feature_name = ['a1', 'a2', 'a3', 'a4', 'a5', 'a6']return dataSet, feature_name

数据预处理

有相应的库可以直接调用

def preProcess(x, y):# 标准化特征缩放  x = (x - 均值) / 标准差"""axis=0，输出矩阵是1行，求每一列的平均；axis=1，输出矩阵是1列，求每一行的平均.keepdims：BOOL，可选如果设置为True，这是减少了轴留在结果与大小为一维。使用此选项，结果会正确地播出，对原来的编曲。"""x -= np.mean(x, axis=0) x /= np.std(x, axis=0, ddof=1)  # ddof = 1 必加# 在x前加上一列1  方便代码中的矩阵操作# np.c_是按行连接两个矩阵，就是把两矩阵左右相加，要求行数相等。x = np.c_[np.ones(len(x)), x]y = np.c_[y]return x, yx, y = preProcess(x, y)# 使用库函数
# coding=gbk
import pandas as pd
from sklearn.preprocessing import StandardScaler# 读取数据
data0 = pd.read_csv('附件三.CSV', encoding='gbk', index_col='客户编号')# 获取每个特征的列名
column_names = data0.columns
# 获取待测特征数据集
x_test = data0[column_names[1:26]].values
# 进行标准化
std = StandardScaler()
x_test = std.fit_transform(x_test)df = pd.DataFrame(x_test,columns=column_names[1:26],index=range(1,16))
df.to_excel('标准化附件三.xlsx')

格式化输出

1.np.ndarray保留小数位数的方法


1.设置set_printoptionsnp.set_printoptions(precision = 8)
a = np.random.randn(4)
print('默认为保留8位小数：', a)2.使用np.aroundprint('保留3位小数：', np.around(a, 3))3.coef = ['{:.4f}'.format(i) for i in LR.coef_]
print(coef)