基于JUPYTER的python主流库新手教程(上)

作者：二马传奇

0. 基本测试

for i in range(5):print(i,end=",")

0,1,2,3,4,

1. numpy教程

1.1 numpy 基础函数

下面是arange方法的用法

import numpy as np
warry=np.arange(0,1,0.2)
print(warry)

[0.  0.2 0.4 0.6 0.8]

下面是linspace方法的用法

warry=np.linspace(0,1,5)
print(warry)

[0.   0.25 0.5  0.75 1.  ]

接着是logspace，用于创建等比数列，起始地址是取过对数之后的数字

warry=np.logspace(0,1,5)
print(warry)

[ 1.          1.77827941  3.16227766  5.62341325 10.        ]

zeros方法同matlab,用法略有区别

print(np.zeros(4))

[0. 0. 0. 0.]

print(np.zeros([4,4]))

[[0. 0. 0. 0.][0. 0. 0. 0.][0. 0. 0. 0.][0. 0. 0. 0.]]

ones 方法，用法同zeros，全一矩阵，这和matlab也是相似的

print(np.ones([4,4]))

[[1. 1. 1. 1.][1. 1. 1. 1.][1. 1. 1. 1.][1. 1. 1. 1.]]

diag 函数,对角矩阵，指定对角线元素，同Matlab

print(np.diag([1,2,3,4]))

[[1 0 0 0][0 2 0 0][0 0 3 0][0 0 0 4]]

1.2 ndarray 对象属性和数据转换

ndim,秩；shape,数组维度；size,数组元素个数；dtype,数组类型；itemsize,数组中每个元素的字节大小；

warray=np.array([[1,2,3],[4,5,6]])
print('秩:',warray.ndim)
print('形状:',warray.shape)
print('元素个数:',warray.size)
print('数据类型:',warray.dtype)
print('数据元素字节大小:',warray.itemsize)

秩: 2
形状: (2, 3)
元素个数: 6
数据类型: int32
数据元素字节大小: 4

1.3 随机数生成方法

用randint生成指定范围的随机整数

print(np.random.randint(100,200,size=(2,4)))

[[102 144 157 134][122 146 132 108]]

rand 函数生成[0,1]随机数组

print(np.random.rand(5))

[0.00671345 0.38544324 0.99597451 0.90532193 0.70969704]

1.4 数组变换

reshape 方法修改数组维度(-1表示数组维度可以通过本身来判断）

arr=np.array([[1,2,3,4],[5,6,7,8]])
print(arr)
print(arr.reshape(4,-1))

[[1 2 3 4][5 6 7 8]]
[[1 2][3 4][5 6][7 8]]

数组横向合并，通过hstack方法,传递的参数是两个矩阵构成的元组

arr1=np.arange(0,6,1).reshape(2,-1)
arr2=arr1*2
print(np.hstack((arr1,arr2)))

[[ 0  1  2  0  2  4][ 3  4  5  6  8 10]]

concatenate通过控制axis参数来控制横向或是纵向合并

print(np.concatenate((arr1,arr2),axis=0))

[[ 0  1  2][ 3  4  5][ 0  2  4][ 6  8 10]]

相反的，也存在数组的横向或纵向的分割，通过hsplit或vsplit或split(axis)来控制

print(np.split(arr1,2,axis=0))

[array([[0, 1, 2]]), array([[3, 4, 5]])]

数组转置，T属性即可，或者transpose，这和matlab是非常像的

print(arr1.T)

[[0 3][1 4][2 5]]

1.5 ufunc函数

print(arr1<arr2)

[[False  True  True][ True  True  True]]

print(arr1**arr2)

[[      1       1      16][    729   65536 9765625]]

ufunc函数的广播机制

x=np.array([[1,2,3],[2,3,4],[3,4,5]])
y=np.array([1,2,3])
print(x+y)

[[2 4 6][3 5 7][4 6 8]]

使用基本的逻辑运算实现数组的条件运算

arr1=np.array([1,2,3,5])
arr2=np.array([2,4,6,8])
cond=np.array([True,False,True,False])
print([(x if c else y)for x,y,c in zip(arr1,arr2,cond)])

[1, 4, 3, 8]

使用where方法处理大规模数组的条件逻辑运算

print(np.where(cond,arr1,arr2))

[1 4 3 8]

print(np.where(arr1>2))

(array([2, 3], dtype=int64),)

1.5 排序

sort方法进行排序

arr=np.array([[4,2,9,5],[6,4,8,3],[1,6,2,4]])
arr.sort(axis=1)
print(arr)

[[2 4 5 9][3 4 6 8][1 2 4 6]]

argsort函数和lexsort函数可以返回原始数据在新数据中的下标

arr=np.array([[4,2,9,5],[6,4,8,3],[1,6,2,4]])
print(arr.argsort())

[[1 0 3 2][3 1 0 2][0 2 3 1]]

1.6 重复数据与去重

unique函数找到数组中的唯一值并返回已排序的结果

names=np.array([3,1,2,2,3,3,3,4,5,5])
print(np.unique(names))

[1 2 3 4 5]

使用tile和repeat实现数据重复

print(np.tile(names,2))
print(np.repeat(names,2))

[3 1 2 2 3 3 3 4 5 5 3 1 2 2 3 3 3 4 5 5]
[3 3 1 1 2 2 2 2 3 3 3 3 3 3 4 4 5 5 5 5]

names=np.array([[1,2,3],[4,5,6]])
print(names.repeat(2,axis=0))
print(names.repeat(2,axis=1))
print(np.tile(names,2))

[[1 2 3][1 2 3][4 5 6][4 5 6]]
[[1 1 2 2 3 3][4 4 5 5 6 6]]
[[1 2 3 1 2 3][4 5 6 4 5 6]]

1.7 常用统计函数

sum,mean,std,var,min,max

arr=np.arange(20).reshape(4,5)
print('数组和:',np.sum(arr))
print('数组纵轴和:',np.sum(arr,axis=0))
print('数组横轴和:',np.sum(arr,axis=1))
print('数组的均值:',np.mean(arr))
print('数组横轴的均值:',np.mean(arr,axis=1))
print('数组标准差:',np.std(arr))

数组和: 190
数组纵轴和: [30 34 38 42 46]
数组横轴和: [10 35 60 85]
数组的均值: 9.5
数组横轴的均值: [ 2.  7. 12. 17.]
数组标准差: 5.766281297335398

2. Pandas教程

pandas三种数据结构: series,dataframe,panel

2.1 series

import pandas as pd
obj=pd.Series([1,-2,3,-4])
print(obj)

0    1
1   -2
2    3
3   -4
dtype: int64

i=["a","c","d","a"]
v=[2,4,5,7]
t=pd.Series(v,index=i,name="col")
print(t)

a    2
c    4
d    5
a    7
Name: col, dtype: int64

两套索引方式:位置和标签

print(t[0])
print(t["a"])

2
a    2
a    7
Name: col, dtype: int64

通过字典创建Series

sdata={'Ohio':35000,"Texas":71000,"Oregon":16000,"Utah":50000}
obj3=pd.Series(sdata)
print(obj3)

Ohio      35000
Texas     71000
Oregon    16000
Utah      50000
dtype: int64

states=['California','Ohio','Oregon','Texas']
obj4=pd.Series(sdata,index=states)
print(obj3+obj4)

California         NaN
Ohio           70000.0
Oregon         32000.0
Texas         142000.0
Utah               NaN
dtype: float64

就地修改Series的index

obj3.index=states
print(obj3)

California    35000
Ohio          71000
Oregon        16000
Texas         50000
dtype: int64

2.2 DataFrame

由等长的列表或者字典创建

import numpy as np
data={'name':['张三','李四'],'sex':['female','male'],'city':['北京','上海']}
df=pd.DataFrame(data,index=np.arange(2))
print(df)

  name     sex city
0   张三  female   北京
1   李四    male   上海

df2=pd.DataFrame(data,columns=['name','sex','city','address'],index=['a','b'])
print(df2)

  name     sex city address
a   张三  female   北京     NaN
b   李四    male   上海     NaN

索引对象

print(df2.index)
print(df2.columns)

Index(['a', 'b'], dtype='object')
Index(['name', 'sex', 'city', 'address'], dtype='object')

插入索引

print(df2.index.insert(1,'w'))

Index(['a', 'w', 'b'], dtype='object')

DataFrame的基本属性: values,index,columns,dtypes,ndim,shape

print(df2.values)
print(df2.ndim)
print(df2.shape)

[['张三' 'female' '北京' nan]['李四' 'male' '上海' nan]]
2
(2, 4)

重建索引：指的是重新给索引排序，使用reindex方法

obj=pd.Series([7.2,-4.3,4.5,3.6],index=['a','b','d','c'])
print(obj)
print(obj.reindex(['a','b','c','d','e'],fill_value=0))

a    7.2
b   -4.3
d    4.5
c    3.6
dtype: float64
a    7.2
b   -4.3
c    3.6
d    4.5
e    0.0
dtype: float64

前/后向填充：对于时间序列而言

import numpy as np
obj=pd.Series([7.2,-4.3,4.5],index=[0,2,4])
print(obj.reindex(np.arange(6),method='ffill'))
print(obj.reindex(np.arange(6),method='bfill'))

0    7.2
1    7.2
2   -4.3
3   -4.3
4    4.5
5    4.5
dtype: float64
0    7.2
1   -4.3
2   -4.3
3    4.5
4    4.5
5    NaN
dtype: float64

更换索引

df5=df.set_index('city')
print(df5)

     name     sex
city
北京     张三  female
上海     李四    male

数据查询

选取列(不可以使用切片)

w1=df['name']
w2=df[['name','city']]
print(w1)
print(w2)

0    张三
1    李四
Name: name, dtype: objectname city
0   张三   北京
1   李四   上海

选取行(可以使用切片)

print(df[:2])
print(df[:1])

  name     sex city
0   张三  female   北京
1   李四    male   上海name     sex city
0   张三  female   北京

使用loc同时索引和标签，索引选取行，标签选取列

print(df.loc[:,['name','city']])
print(df.loc[[0],['name']])

  name city
0   张三   北京
1   李四   上海name
0   张三

使用iloc行和列均通过索引来选取

a={'name':['王五','刘九'],'city':['深圳','广州'],'sex':['male','female']}
df1=pd.DataFrame(a)
df2=pd.concat([df,df1],ignore_index=True)
print(df2)
print(df2.iloc[[1,3],[1,2]])

  name     sex city
0   张三  female   北京
1   李四    male   上海
2   王五    male   深圳
3   刘九  female   广州sex city
1    male   上海
3  female   广州

布尔选择（同matlab)

print(df2[df2['city']=='上海'])

  name   sex city
1   李四  male   上海

增加一行数据(append,concat)

append只能增加一行

data1={'city':'南京','sex':'male','name':'马六'}
df3=df2.append(data1,ignore_index=True)
print(df3)

  name     sex city
0   张三  female   北京
1   李四    male   上海
2   王五    male   深圳
3   刘九  female   广州
4   马六    male   南京

使用loc直接添加

df2.loc[5]=['沈七','male','武汉']
print(df2)

  name     sex city
0   张三  female   北京
1   李四    male   上海
2   王五    male   深圳
3   刘九  female   广州
5   沈七    male   武汉

使用concat合并两个DataFrame(上面已经举过了例子)

增加一列数据(直接通过新标签赋值)

df2['age']=[19,20,56,28,39]
print(df2)

  name     sex city  age
0   张三  female   北京   19
1   李四    male   上海   20
2   王五    male   深圳   56
3   刘九  female   广州   28
5   沈七    male   武汉   39

删除数据

删除数据的行

print(df2.drop(5))

  name     sex city  age
0   张三  female   北京   19
1   李四    male   上海   20
2   王五    male   深圳   56
3   刘九  female   广州   28

删除数据的列 axis=1,删除列，否则删除行，inplace=True直接在原数据上操作，否则返回一个副本

df2.drop('age',axis=1,inplace=True)
print(df2)

  name     sex city
0   张三  female   北京
1   李四    male   上海
2   王五    male   深圳
3   刘九  female   广州
5   沈七    male   武汉

2.3 函数应用和映射

map:将函数套用到Series的每个元素中

df2['age']=['19岁','20岁','56岁','28岁','39岁']
print(df2)
def f(x):return int(x.split('岁')[0])
df2['age']=df2['age'].map(f)
print(df2)

  name     sex city  age
0   张三  female   北京  19岁
1   李四    male   上海  20岁
2   王五    male   深圳  56岁
3   刘九  female   广州  28岁
5   沈七    male   武汉  39岁name     sex city  age
0   张三  female   北京   19
1   李四    male   上海   20
2   王五    male   深圳   56
3   刘九  female   广州   28
5   沈七    male   武汉   39

apply:将函数套用到DataFrame的行与列上，通过axis参数设置

df3=pd.DataFrame(np.random.randn(3,3),columns=['a','b','c'],index=['app','win','mac'])
print(df3)
print('\n')
df4=df3.apply(np.mean,axis=1)
print(df4)

            a         b         c
app  1.193534  0.778194  1.952184
win  0.318285  0.213218  0.291229
mac  1.288238 -0.946410  0.726388app    1.307971
win    0.274244
mac    0.356072
dtype: float64

applymap函数:将函数套用到DataFrame的每个元素上，用于批量处理大数据

df4=df3.applymap(lambda x:round(x,3))
print(df4)

         a      b      c
app  1.194  0.778  1.952
win  0.318  0.213  0.291
mac  1.288 -0.946  0.726

2.4 排序

Series中，通过sort_index方法对索引进行排序，通过sort_values方法对数值进行排序

wy=pd.Series([2,6,5,4],index=['a','b','d','c'])
print(wy)
print(wy.sort_index())
print(wy.sort_values())

a    2
b    6
d    5
c    4
dtype: int64
a    2
b    6
c    4
d    5
dtype: int64
a    2
c    4
d    5
b    6
dtype: int64

利用by参数在一个DataFrame中按照某一个col_name来排序

wdf=pd.DataFrame(wy,columns=['num'])
wdf['year']=['2019','2020','2016','2005']
print(wdf.sort_values(by='year'))

   num  year
c    4  2005
d    5  2016
a    2  2019
b    6  2020

2.5 汇总与统计

sum按行或列进行汇总

print('按列汇总:\n',df4.sum())
print('\n')
print('按行汇总:\n',df4.sum(axis=1))

按列汇总:a    2.800
b    0.045
c    2.969
dtype: float64按行汇总:app    3.924
win    0.822
mac    1.068
dtype: float64

用describe函数对数据进行初步统计

print('列描述')
df4.describe().T

列描述

	count	mean	std	min	25%	50%	75%	max
a	3.0	0.933333	0.534963	0.318	0.7560	1.194	1.2410	1.288
b	3.0	0.015000	0.878890	-0.946	-0.3665	0.213	0.4955	0.778
c	3.0	0.989667	0.861319	0.291	0.5085	0.726	1.3390	1.952

print('行描述')
df4.T.describe().T

行描述

	count	mean	std	min	25%	50%	75%	max
app	3.0	1.308	0.595244	0.778	0.986	1.194	1.5730	1.952
win	3.0	0.274	0.054525	0.213	0.252	0.291	0.3045	0.318
mac	3.0	0.356	1.162052	-0.946	-0.110	0.726	1.0070	1.288

value_counts实现频数统计:

print(df4['a'].value_counts())

1.194    1
0.318    1
1.288    1
Name: a, dtype: int64

print(df4.loc['mac'].value_counts())

-0.946    11.288    10.726    1
Name: mac, dtype: int64

2.6 数据分组与聚合

groupby方法实现高效分组

da=pd.DataFrame({'key1':['a','a','b','b','a'],'key2':['yes','no','yes','yes','no'],'data1':np.random.randn(5),'data2':np.random.randn(5)})
print(da)
grouped=da['data1'].groupby(da['key1'])
print(grouped)
print(grouped.size())
print(grouped.mean())

  key1 key2     data1     data2
0    a  yes  1.525793 -0.275040
1    a   no -0.086230  1.717356
2    b  yes  1.091938 -0.955356
3    b  yes -1.859716  1.926496
4    a   no  1.586969 -0.406096
<pandas.core.groupby.generic.SeriesGroupBy object at 0x0000016C80400C48>
key1
a    3
b    2
Name: data1, dtype: int64
key1
a    1.008844
b   -0.383889
Name: data1, dtype: float64

按列名分组

groupk1=da.groupby('key2').mean()
groupk1

	data1	data2
key2
no	0.750369	0.655630
yes	0.252671	0.232033

还可以根据和DataFrame行数相同的自定义列表或元组来分组

k=da.groupby([0,0,0,1,1]).sum()
k

	data1	data2
0	2.531500	0.48696
1	-0.272747	1.52040

还可以按函数来分

def judge(x):return'a' if x>0 else 'b'
k=da['data1'].groupby(da['data1'].map(judge)).sum()
k

data1
a    4.204700
b   -1.945947
Name: data1, dtype: float64

利用agg计算出当前数据对应的统计量

da[["data1","data2"]].agg([np.sum,np.mean])

	data1	data2
sum	2.258753	2.007360
mean	0.451751	0.401472

计算各个字段的不同统计量

da.agg({'data1':np.mean,'data2':[np.std,np.mean]})

	data1	data2
mean	0.451751	0.401472
std	NaN	1.323638

混用数据的分组和聚合

da.groupby(['key1','key2'])['data1'].agg(np.mean)

key1  key2
a     no      0.750369yes     1.525793
b     yes    -0.383889
Name: data1, dtype: float64

transform或apply方法将运算分布到每一行

da.groupby(['key1','key2'])['data1'].transform('mean')

0    1.525793
1    0.750369
2   -0.383889
3   -0.383889
4    0.750369
Name: data1, dtype: float64

da.groupby(['key1','key2'])['data1'].apply(np.mean)

key1  key2
a     no      0.750369yes     1.525793
b     yes    -0.383889
Name: data1, dtype: float64

2.7 数据透视表

pivot_table默认计算均值

da.pivot_table(index='key1',columns='key2')

	data1		data2
key2	no	yes	no	yes
key1
a	0.750369	1.525793	0.65563	-0.27504
b	NaN	-0.383889	NaN	0.48557

改为求和

da.pivot_table(index='key1',columns='key2',aggfunc='sum')

	data1		data2
key2	no	yes	no	yes
key1
a	1.500739	1.525793	1.31126	-0.27504
b	NaN	-0.767779	NaN	0.97114

crosstab方法画交叉表计算分组频率

pd.crosstab(da['key1'],da['key2'],margins=True)

key2	no	yes	All
key1
a	2	1	3
b	0	2	2
All	2	3	5

2.8 pandas可视化

Series的plot方法绘图

import matplotlib.pyplot as plt
s=pd.Series(np.random.normal(size=10))
s.plot()

<matplotlib.axes._subplots.AxesSubplot at 0x16c81121248>

DataFrame的plot方法绘图

ddp=pd.DataFrame({'normal':np.random.normal(size=50),'gamma':np.random.gamma(1,size=50)})
ddp.plot()

<matplotlib.axes._subplots.AxesSubplot at 0x16c81597a88>

柱状图

print(da['key1'].value_counts())
print(da['key1'].value_counts().plot(kind='bar',rot=30))

a    3
b    2
Name: key1, dtype: int64
AxesSubplot(0.125,0.125;0.775x0.755)

直方图和密度图

wy=pd.Series(np.random.normal(size=80))
s.hist(bins=15,grid=False)

<matplotlib.axes._subplots.AxesSubplot at 0x16c81675dc8>

s.plot(kind='kde')

<matplotlib.axes._subplots.AxesSubplot at 0x16c81657648>

散点图

da.plot(kind='scatter',x='data1',y='data2')

<matplotlib.axes._subplots.AxesSubplot at 0x16c8343f808>

2.9 数据合并

merge 默认内连接返回交集，通过how参数可以修改连接方式

price=pd.DataFrame({'fruit':['apple','grape','orange'],'price':[8,7,9]})
amount=pd.DataFrame({'fruit':['apple','grape','orange'],'amount':[5,11,8]})
display(price,amount,pd.merge(price,amount))

	fruit	price
0	apple	8
1	grape	7
2	orange	9

	fruit	amount
0	apple	5
1	grape	11
2	orange	8

	fruit	price	amount
0	apple	8	5
1	grape	7	11
2	orange	9	8

display(pd.merge(price,amount,how='outer'))

	fruit	price	amount
0	apple	8	5
1	grape	7	11
2	orange	9	8

concat方法（直接堆积）

display(pd.concat([price,amount],axis=1))

	fruit	price	fruit	amount
0	apple	8	apple	5
1	grape	7	grape	11
2	orange	9	orange	8

总结:

combine_first方法，保留w1的信息，补充w2和w1不相同的信息
concat方法，按列合并时保留w1和w2索引相同的信息，丢弃w2冗余的信息(outer),按行合并时直接将w2补充在w1下面，索引不合并
merge方法，how='inner’时默认取w1和w2行数据的交集，how='outer’时取行数据的并集，注意会改变原始索引

综上，merge方法适合统计w1和w2中所有不同行数据或相同行数据的清单，concat方法适合进行行列追加，combine_first方法适合于对于包含相同索引的w1和w2进行合并，即取长补短。

w1=pd.DataFrame({0:[0,2],1:[0,5]},index=['a','b'])
w2=pd.concat([pd.DataFrame({0:[0,1],1:[0,5]},index=['a','b']),pd.DataFrame({1:[5,6]},index=['f','g'])])
display(w1,w2)
display(pd.concat([w1,w2],axis=1,join='inner'))
display(pd.merge(w1,w2,how='outer'))
display(w1.combine_first(w2))

	0	1
a	0	0
b	2	5

	0	1
a	0.0	0
b	1.0	5
f	NaN	5
g	NaN	6

	0	1	0	1
a	0	0	0.0	0
b	2	5	1.0	5

	0	1
0	0.0	0
1	2.0	5
2	1.0	5
3	NaN	5
4	NaN	6

	0	1
a	0.0	0.0
b	2.0	5.0
f	NaN	5.0
g	NaN	6.0

2.10 数据清洗

isnull可以直接判断该列中的那个数据为NaN

w3=w1.combine_first(w2)
w3.isnull()

	0	1
a	False	False
b	False	False
f	True	False
g	True	False

使用isnull().sum()统计缺失值

w3.isnull().sum()

0    2
1    0
dtype: int64

用info方法查看

w3.info()

<class 'pandas.core.frame.DataFrame'>
Index: 4 entries, a to g
Data columns (total 2 columns):#   Column  Non-Null Count  Dtype
---  ------  --------------  -----  0   0       2 non-null      float641   1       4 non-null      float64
dtypes: float64(2)
memory usage: 96.0+ bytes

使用dropna方法删除有缺失值的行

w4=w3.dropna()
display(w4)

	0	1
a	0.0	0.0
b	2.0	5.0

通过布尔型索引,对Series操作

not_null=w3[0].notnull()
print(not_null)
print(w3[0][not_null])

a     True
b     True
f    False
g    False
Name: 0, dtype: bool
a    0.0
b    2.0
Name: 0, dtype: float64

thresh参数要求一行至少N个非NAN才能存活

display(w3)
w4=w3.dropna(thresh=1)
display(w4)
w4=w3.dropna(thresh=2)
display(w4)

	0	1
a	0.0	0.0
b	2.0	5.0
f	NaN	5.0
g	NaN	6.0

	0	1
a	0.0	0.0
b	2.0	5.0
f	NaN	5.0
g	NaN	6.0

	0	1
a	0.0	0.0
b	2.0	5.0

填充缺失值 fillna，传一个常数或者字典

w4=w3.fillna(0)
display(w4)

	0	1
a	0.0	0.0
b	2.0	5.0
f	0.0	5.0
g	0.0	6.0

使用duplicated方法检测和处理重复值

data=pd.DataFrame({'k1':['one','two']*3+['two'],'k2':[1,1,2,3,1,4,4],'k3':[1,1,5,2,1,4,4]})
print(data)
data.duplicated()

    k1  k2  k3
0  one   1   1
1  two   1   1
2  one   2   5
3  two   3   2
4  one   1   1
5  two   4   4
6  two   4   40    False
1    False
2    False
3    False
4     True
5    False
6     True
dtype: bool

drop_duplicates方法删除重复的行

data.drop_duplicates()

	k1	k2	k3
0	one	1	1
1	two	1	1
2	one	2	5
3	two	3	2
5	two	4	4

使用散点图，箱线图或者3σ\sigmaσ法则来判断异常数据

wdf=pd.DataFrame(np.arange(20),columns=['W'])
wdf['Y']=wdf['W']*1.5+2
wdf.iloc[3,1]=128
wdf.iloc[18,1]=150
wdf.plot(kind='scatter',x='W',y='Y')

<matplotlib.axes._subplots.AxesSubplot at 0x16c8374e808>

plt.boxplot(wdf['Y'].values,notch=True)

{'whiskers': [<matplotlib.lines.Line2D at 0x16c838c5f48>,<matplotlib.lines.Line2D at 0x16c838d4e48>],'caps': [<matplotlib.lines.Line2D at 0x16c838d9b48>,<matplotlib.lines.Line2D at 0x16c838d9c88>],'boxes': [<matplotlib.lines.Line2D at 0x16c838d4c08>],'medians': [<matplotlib.lines.Line2D at 0x16c838d9d08>],'fliers': [<matplotlib.lines.Line2D at 0x16c838e1a08>],'means': []}

k=wdf['Y'][abs(wdf['Y']-wdf['Y'].mean())>3*wdf['Y'].std()]
display(k)

18    150.0
Name: Y, dtype: float64

2.11 数据转换

使用replace方法替换

data=pd.DataFrame({'name':['alice','bob','cindy','dick'],'sex':['male','','male','female']})
display(data)
data2=data.replace('','unknown')
display(data2)

	name	sex
0	alice	male
1	bob
2	cindy	male
3	dick	female

	name	sex
0	alice	male
1	bob	unknown
2	cindy	male
3	dick	female

replace传入列表

data2=data2.replace(['alice','bob'],['Alice','Bob'])
display(data2)

	name	sex
0	Alice	male
1	Bob	unknown
2	cindy	male
3	dick	female

replace方法传入字典替换

data2=data2.replace({'male':'M','female':'F','unknown':'U'})
display(data2)

	name	sex
0	Alice	M
1	Bob	U
2	cindy	M
3	dick	F

使用函数映射进行替换

data2['grades']=[96,75,59,80]
display(data2)
def G(x):if x>80 and x<100:return 'excellent'elif x>=60 and x<=80:return 'good'else:return 'bad'
data2['grades']=data2['grades'].map(G)
display(data2)

	name	sex	grades
0	Alice	M	96
1	Bob	U	75
2	cindy	M	59
3	dick	F	80

	name	sex	grades
0	Alice	M	excellent
1	Bob	U	good
2	cindy	M	bad
3	dick	F	good

2.12 数据标准化

离差标准化: x1=x−minmax−minx_1=\frac{\mathbf{x}-\mathbf{min}}{\mathbf{max}-\mathbf{min}}x1=max−minx−min

num=pd.DataFrame(np.random.randint(100,200,size=(3,3)),columns=['a','b','c'])
display(num)
print(num.min())
def nor(S):S=(S-S.min())/(S.max()-S.min())return  S
num2=nor(num)
display(num2)

	a	b	c
0	157	150	101
1	123	164	177
2	199	152	111

a    123
b    150
c    101
dtype: int32

	a	b	c
0	0.447368	0.000000	0.000000
1	0.000000	1.000000	1.000000
2	1.000000	0.142857	0.131579

利用cut方法来进行量化

score=np.random.randint(25,100,size=10)
print(score)
bins=[0,59,70,80,100]
score_cut=pd.cut(score,bins)
print(pd.value_counts(score_cut))

[87 73 87 47 49 86 45 26 63 64]
(0, 59]      4
(80, 100]    3
(59, 70]     2
(70, 80]     1
dtype: int64

教程的上半部分到此结束，关于Matplotlib,Seaborn等库的介绍详见教程的下半部分