数据预处理(纯干货，适合小白学习)
数据预处理
数据清洗
- 数据清洗目的：将脏数据（这里指是对数据分析没有意义、格式非法、不在指定范围的数据）清洗干净，是原数据具有完整性、唯一性、权威性、合法性、一致性等特点。
- pandas常见数据清洗：空值和缺失值的处理，重复值的处理，异常值的处理，统一数据格式。
空值和缺失值的处理
- 空值：数据未知，不适用或将在以后添加数据。None
- 缺失值：数据集中或某些属性的值是不完整的，产生的原因主要有人为原因和机械原因，机器原因是由于机械故障未能是搜集或存储失败，认为原因是由主观失误或有意隐瞒造成。NaN
- 使用isnull和notnull函数可以判断数据集中是否存在空值和缺失值，对于缺失数据可以使用dropna()和fillna()方法进行删除和填充
- isnull()函数和notnull()函数
- isnull()函数和notnull()函数的语法格式如下：
pandas.isnull(obj) 存在NaN或者None的话则就将在这个位置标记True，否则标记False
pandas.notnull(obj) 存在NaN或者None的话则就将在这个位置标记False，否则标记True
ser_obj = Series([1,NaN,None]) #notnull
pd.notnull(ser_obj)
0 True
1 False
2 False
dtype: bool
pd.isnull(ser_obj) #isnull
0 False
1 True
2 True
dtype: bool
pd.isna(ser_obj) #isna
0 False
1 True
2 True
dtype: bool
- dropna()方法
- dropna()的方法是删除含有空值和缺失值的行和列，
- dropna(axis=0,how=‘any’,thresh=None,subset=None,inplace=False)
- axis:确定过滤行或列，取值可以为
0或index：删除包含缺失值的行，默认为0
1或columns:删除包含缺失值的列
- how:
any:默认值，如果存在NaN值，则删除该行或者该列
all：如果所有值都是NaN值，则删除该行或者该列
- thresh:表示有效数据量的最小要求，若传入了2，则是要求该行或该列至少有两个非NaN值时将其保留
- subset:表示在特定的子集中寻找空值
- inplace:表示是否在原数据上操作，如果设置为True，则表示修改源数据，如果设置为False，则表示修改原数据的副本，返回新的数据
df_obj = pd.DataFrame({'类别':['小说','随笔散文','青春文字','传记'],
'书名':[NaN,'《皮囊》','《旅行结束时》','《老舍自传》'],
'作者':['老舍',None,'张琪新','老舍']})
df_obj
类别 书名 作者
0 小说 NaN 老舍
1 随笔散文 《皮囊》 None
2 青春文字 《旅行结束时》 张琪新
3 传记 《老舍自传》 老舍
df_obj.dropna()
类别 书名 作者
2 青春文字 《旅行结束时》 张琪新
3 传记 《老舍自传》 老舍
- 填充空值和缺失值
- 填充空值和缺失值的方法有很多，比如人工填写，特殊值填写，热卡填充等，在pd中的fillna()方法可以实现填充空值或缺失值
- fillna(
value=None,
method=None,
axis=None,
inplace=False,
limit=None,
downcast=None,
**kwargs,
) - value:用于填充的数值
- method：表示填充方式，默认值为None，另外还有以下取值
ffill：将最后一个有效数据向后传播，也就是说用缺失值前面以得一个值代替缺失值
bfill：将最后一个有效值向前传播，也就是说用缺失值后面的一个值代替缺失值
limit：可以连续填充的最大数量，默认为None
df_obj = pd.DataFrame({'A':[1.0,2.0,3.0,NaN],'B':[NaN,2.0,NaN,6.0],'C':['a',7,8,9],'D':[NaN,2.0,3.0,NaN]})
df_obj #查看原数据
A B C D
0 1.0 NaN a NaN
1 2.0 2.0 7 2.0
2 3.0 NaN 8 3.0
3 NaN 6.0 9 NaN
df_obj.fillna(66) #使用66进行填充
A B C D
0 1.0 66.0 a 66.0
1 2.0 2.0 7 2.0
2 3.0 66.0 8 3.0
3 66.0 6.0 9 66.0
df_obj.fillna({'A':5.0,'B':8.0,'C':99}) #传入字典根据索引进行填充
A B C D
0 1.0 8.0 a NaN
1 2.0 2.0 7 2.0
2 3.0 8.0 8 3.0
3 5.0 6.0 9 NaN
df_obj.fillna(method='bfill') #使用缺失值后边一个的数据进行填充
A B C D
0 1.0 2.0 a 2.0
1 2.0 2.0 7 2.0
2 3.0 6.0 8 3.0
3 NaN 6.0 9 NaN
重复值的处理
- 当数据出先重复值的时候，大部分时间都需要把重复值进行删除，pandas提供了两个方法专门处理数据中的重复值，分别为duplicated()和drop_duplicates()方法
- duplicated:确认是否有缺失值
- drop_duplicates:删除缺失值
- 使用duplicated()方法处理重复值
duplicated(subset=None,keep=‘first’)
- subset:用于识别重复的列标或列标签序列，默认识别所有的列标签
- keep:删除重复项并保留第一次出现的项，取值可以为first，last，False（first:从前向后查找，除了第一次出现外，其余相同的标记为重复，last：从后向前查找，除了最后一次出现外，其余相同的标记为重复，False：所有相同的都标为重复）
df_obj = pd.DataFrame({'id':[1,2,3,4,4,5],
'name':['小鸣','小月月','彭艳','硫化','硫化','周华'],
'age':[18,18,29,58,58,36],
'height':[180,180,185,175,175,178],
'gender':['女','女','男','男','男','男']})
df_obj
id name age height gender
0 1 小鸣 18 180 女
1 2 小月月 18 180 女
2 3 彭艳 29 185 男
3 4 硫化 58 175 男
4 4 硫化 58 175 男
5 5 周华 36 178 男
df_obj.duplicated() #从前向后查找重复值
0 False
1 False
2 False
3 False
4 True
5 False
dtype: bool
- drop_duplicates(subset=None, keep=‘first’, inplace=False)
- subset:用于识别重复的列标或列标签序列，默认识别所有的列标签
- keep:删除重复项并保留第一次出现的项，取值可以为first，last，False（first:从前向后查找，除了第一次出现外，其余相同的标记为重复，last：从后向前查找，除了最后一次出现外，其余相同的标记为重复，False：所有相同的都标为重复）
- inplace:参数接受一个布尔类型的值，表示是否替换原来的数据，默认为False
df_obj.drop_duplicates()
id name age height gender
0 1 小鸣 18 180 女
1 2 小月月 18 180 女
2 3 彭艳 29 185 男
3 4 硫化 58 175 男
5 5 周华 36 178 男
异常值处理
- 基于拉依达原理：它是指假设一组数据只含有随机误差，对其进行计算处理得到的标准偏差，按一定概率确定一个区间，凡是超过这个区间的误差都是粗大误差，在此误差范围内的数据都应予以剔除
我的理解就是数据要在(u-3a,u+3a)之间 u是平均值 a是标准差
- 定义一个基于本原理的函数，用来检测一组数据中是否有异常值
arr = pd.DataFrame({'A':[1,1,2,3,4,5,6,4,8,5,1,4,52,],'B':[1,2,2,6,8,321,5,4,8,1,3,5,1]})
arr
A B
0 1 1
1 1 2
2 2 2
3 3 6
4 4 8
5 5 321
6 6 5
7 4 4
8 8 8
9 5 1
10 1 3
11 4 5
12 52 1
import numpy as np
def three_sigma(arr):
#求平均值
mean_value = arr.mean()
#求标准差
std_value = arr.std()
#位于(u-3a,u+3a)的值为正常值，不在这个区间的就是异常值，一旦发现异常值就标记为True，否则标记为False
rule = ((mean_value-3 * std_value>arr)) | ((mean_value+3*std_value- 基于箱型图检测异常值
- 在箱型图中异常值通常被定义为小于Ql+1.5QR或大于Qu+1.5IQR的值
- Ql被称为下四分位数，表示全部观察四分之一的数据取值比他小
- Qu成为上四分位数，表示全部观察值中有四分之一的数据取值比他小
- IQR成为四分位数间距，是上四分位数Qu与下四分位数Ql之差，其间包含了全部观察值的一半
- 为了能从箱型图中查看异常值，Pandas中提供给了一个boxplot()方法，专门用于绘制箱型图
df = pd.DataFrame({'A':[1,2,3,4],
'B':[2,2,3,2],
'C':[1,4,7,4],
'D':[1,2,30,4]})
df.boxplot(column=['A','B','C','D'])
- 检测出异常值后，通常采用的方式有以下四种
- 直接将含有异常值的记录删除
- 用具体的值进行替换，可用前后两个观测值的平均值修正该异常值
- 不处理，直接在具有异常值的数据集上进行统计分析
- 视为缺失值，利用缺失值的处理方法处理该异常值
- 修改异常值可以用replace()方法进行替换，既可以替换单个数据，也可以多个数据执行批量替换操作
- replace(
to_replace=None,
value=None,
inplace=False,
limit=None,
regex=False,
method=‘pad’,
) - to_replace:表示查找被替换值的方式
- value：用来替换任何匹配to_replace的值，默认值为None
- limit：表示前向或后向填充的最大间隙
- regex：接受布尔值或与to_replace相同的类型，默认为False，表示是否将to_replace和value解释为正则表达式
- method：ffill向前填充 bfill向后填充
接上边代码中的df
df.replace(to_replace=30,value=2)
A B C D
0 1 2 1 1
1 2 2 4 2
2 3 3 7 2
3 4 2 4 4
更改数据类型
- 使用dtype属性进行查看数据类型
- 可以在创建对象时指定数据类型
- 通过astype()方法强行转换数据类型
astype(dtype,compy=True,errors= ‘raise’,**kwargs)（除数字以外的数据会报错）
- dtype:表示数据的类型
- copy：是否建立副本，默认为True
- erroes：错误采取的处理方式，可以取值为raise或ignore，默认为raise，其中raise表示允许引发异常，ignore表示抑制异常
df = pd.DataFrame({'A':['1','2','3','4'],
'B':['-1','-2','33','24']})
df = df.astype(dtype='int')
df
A B
0 1 -1
1 2 -2
2 3 33
3 4 24
df.dtypes
A int32
B int32
dtype: object
- 通过to_numeric()函数转换数据类型
- to_numeric()函数可以解决astype转换类型时，除数字以外的数据会报错的问题，
- pandas.to_numeric(arg,errors=‘raise’,downcast=None)
- arg：表示要转换的数据，可以是list tuple Series
- erroes：错误采取的处理方式
astype和to_numeric的区别(我自己理解的不喜勿喷)：astype转换类型时需要看原数据的类型，如果原数据是’5.5’这种的数据，在转int类型时会报错
ser_obj = pd.Series(['1.5','5'])
ser_obj
0 1.5
1 5
dtype: object
pd.to_numeric(arg=ser_obj,downcast='integer')
0 1.5
1 5.0
dtype: float64
数据合并
- pandas在合并数据集时，常见的操作有轴向堆叠数据、主键合并数据、根据行索引合并数据和合并重叠数据，这些操作各有各的特点。
轴向堆叠数据
- concat()函数可以沿着以条轴将多个对象进行堆叠，
- pd.concat(
objs,
axis=0,
join=‘outer’,
join_axes=None,
ignore_index=False,
keys=None,
levels=None,
names=None,
verify_integrity=False,
sort=None,
copy=True,
) - axis：表示连接的轴向，可以为0或者1，默认为0
- join：表示连接的方式，inner表示内连接，outer表示外连接，默认为外连接
- ignore_index:接受布尔值，默认为False，如果设置为True，则表示清楚现在有的索引并重置索引值
- keys：接收序列，表示添加最外层索引
- levels：用于构建MultIndex的特定级别(唯一值)
- names：在设置了keys和level参数后，用于创建分层级别的名称
- verify_integerity:检查新的链接轴是否包含重复项，接收布尔值，当设置为True时，如果有重复的轴将会抛出错误，默认为False
内连接所得结果是他们的交集，外连接是他们的并集
- 横向堆叠和外连接
df1 = pd.DataFrame({'A':['A0','A0','A1'],
'B':['B0','B0','B1']})
df2 = pd.DataFrame({'C':['C0','C0','C1','C3'],
'D':['D0','D2','D2','D3']})
pd.concat([df1,df2],join='outer',axis=1)
A B C D
0 A0 B0 C0 D0
1 A0 B0 C0 D2
2 A1 B1 C1 D2
3 NaN NaN C3 D3
- 纵向堆叠和内连接
df1 = pd.DataFrame({'A':['A0','A0','A1'],
'B':['B0','B0','B1']})
df2 = pd.DataFrame({'B':['C0','C0','C1','C3'],
'D':['D0','D2','D2','D3']})
pd.concat([df1,df2],axis=0,join='inner')
B
0 B0
1 B0
2 B1
0 C0
1 C0
2 C1
3 C3
主键合并数据
- 主键合并就是根据一个或多个键将不同的DataFrame对象连接起来，大多数是将两个DataFrame对象中重叠的列作为合并的键，Pandas中提供了用于主键合并的merge(),
- pd.merge(
left,
right,
how=‘inner’,
on=None,
left_on=None,
right_on=None,
left_index=False,
right_index=False,
sort=False,
suffixes=(’_x’, ‘_y’),
copy=True,
indicator=False,
validate=None,
) - left：参与合并的左侧DataFrame对象
- right：参与合并的右侧的DataFrame对象
- how：连接方式，默认为inner，支持以下连接方式
- left:使用左侧的DataFrame的键，类似于SQL的左外连接
- right：使用右侧的DataFrame的键，类似于SQL的右外连接
- outer：使用两个DataFrame所有键，类似于SQL的全连接
- inner：使用两个DataFrame键的交集，类似于SQL的内连接
- on:用于连接的列名，必须存在于左右两个DataFrame对象中
- left_on：以左侧DataFrame作为连接键
- right_on：以右侧DataFrame作为连接键
- left_index：左侧的行索引用作连接键
- right_index：右侧的行索引用作连接键
- sort：是否排序，接受布尔值，默认是False
- suffixes：用于追加到重叠列名的末尾，默认为(_x,_y)
在使用merge()函数时，默认会使用重叠的列作为合并键，并采用内连接方式合并数据，既取行索引重叠的部分
left = pd.DataFrame({'key':['K0','K1','K2'],
'A':['A0','A1','A2'],
'B':['B0','B1','B2']})
right = pd.DataFrame({'key':['K0','K1','K2','K3'],
'C':['C0','C1','C2','C3'],
'D':['D0','D1','D2','D3']})
left
key A B
0 K0 A0 B0
1 K1 A1 B1
2 K2 A2 B2
right
key C D
0 K0 C0 D0
1 K1 C1 D1
2 K2 C2 D2
3 K3 C3 D3
pd.merge(left,right,on='key') #通过key来连接
key A B C D
0 K0 A0 B0 C0 D0
1 K1 A1 B1 C1 D1
2 K2 A2 B2 C2 D2
- 两个主键和并
left = pd.DataFrame({'key':['K0','K1','K2'],
'A':['A0','A1','A2'],
'B':['B0','B1','B2']})
right = pd.DataFrame({'key':['K0','K1','K2','K3'],
'B':['B0','B1','B2','B3'],
'D':['D0','D1','D2','D3']})
left
key A B
0 K0 A0 B0
1 K1 A1 B1
2 K2 A2 B2
right
key B D
0 K0 B0 D0
1 K1 B1 D1
2 K2 B2 D2
3 K3 B3 D3
pd.merge(left,right,on=['key','B'])
key A B D
0 K0 A0 B0 D0
1 K1 A1 B1 D1
2 K2 A2 B2 D2
-
内外向连接和轴向堆叠的内外连接时一样的，这里就不演示代码部分了
-
左连接就是分别按照左边表为基准连接，右连接相反，这里也不演示代码了
-
即使左右两个表没有重叠的部分也可以强行拼接，只需要将left_index和right_index设置为True即可
left = pd.DataFrame({'A':['A0','A1','A2'],
'B':['B0','B1','B2']})
right = pd.DataFrame({'C':['C0','C1','C2','C3'],
'D':['D0','D1','D2','D3']})
pd.merge(left,right,left_index=True,right_index=True)
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
根据行索引合并数据
- join(other,on=None,how=‘left’,lsuffix=’’,sort=False)
- on:用于连接列名
- how:可以从{‘left’,‘right’,‘outer’,‘inner’}中任选一个，默认使用left的方式
- lsuffix:接受字符串，用于在左侧重叠的列名后添加后缀名
- rsuffix:接收字符串，用于在右侧重叠的列名后添加后缀名
- sort:接收布尔值，根据连接键对合并的数据进行排序，默认为False
- 当两张表没有重叠的索引时，可以设置merge()函数的left_index和right_index参数，而对join来说只需要将表名作为参数传入即可，join方法默认使用左连接方式，
left = pd.DataFrame({'A':['A0','A1'],
'B':['B0','B1']},index=['a','b'])
right = pd.DataFrame({'C':['C0','C1'],
'D':['D0','D1']},index=['c','d'])
left.join(right,how='outer')
A B C D
a A0 B0 NaN NaN
b A1 B1 NaN NaN
c NaN NaN C0 D0
d NaN NaN C1 D1
- 假设两个表中行索引和列索引重叠，那么当使用join方法进行合并时，使用参数on指定重叠的列名即可
left = pd.DataFrame({'A':['A0','A1','A2'],
'B':['B0','B1','B2'],'key':['k0','k1','k2']})
right = pd.DataFrame({'C':['C0','C1','C2'],
'D':['D0','D1','D2']},index=['k0','k1','k2'])
left.join(right,on='key')
A B key C D
0 A0 B0 k0 C0 D0
1 A1 B1 k1 C1 D1
2 A2 B2 k2 C2 D2
合并重叠数据
当一个DataFrame对象出现了缺失数据，而对于这些缺失数据，我们以往可以使用其他的DataFrame对象进行填充，可以使用combine_first()方法进行填充
需要强调的是，想要用right来填充left数据时，他们必须拥有重叠部分
数据重塑
重塑层次化索引
- pandas中重塑层次化索引的方法有两种：stack()和unstack()，前者是将数据的列旋转为行，后者是将数据的行旋转为列
- stack():将数据的列索引转换为行索引
- DataFrame.stack(level=-1,dropna=True)
- level:表示操作内层索引，若设为0，表示操作外层索引，默认为-1
- dropna:表示是否将旋转后的缺失值删除，若设为True。则表示自动过滤缺失值，设置为Flase则相反
df = pd.DataFrame({'A':['A0','A1','A2'],
'B':['B0','B1','B2']})
df
A B
0 A0 B0
1 A1 B1
2 A2 B2
result = df.stack()
result
0 A A0
B B0
1 A A1
B B1
2 A A2
B B2
dtype: object
- unstack()：将数据行索引转换为类索引
- DataFrame.unstack(level = -1,fill_value= None)
- level：表示操作内层索引，若设置为0则操作外层索引，默认为-1
- fill_value:若产生了缺失值，则可以设置这个参数用来代替NaN
result1 = result.unstack()
result1
A B
0 A0 B0
1 A1 B1
2 A2 B2
轴向旋转
- 根据给定的行索引或列索引重新组织一个DataFrame对象
DataFrame.pivot(index=None,columns=None,values=None)
- index:用于创建新DataFrame对象的行索引，如果未设置，则使用原DataFrame对象的索引
- colums:用于创建新DataFrame对象的列索引，如果未设置，则使用原DataFrame对象的索引
- values:用于创建新DataFrame对象中的值
df = pd.DataFrame({'商品名称':['荣耀9青春版','小米6x','oppo al','荣耀9青春版','小米6x','oppo al'],
'出售日期':['2017.05.25','2017.05.25','2017.05.25','2017.06.18','2017.06.18','2017.06.18'],
'价格':['999元','1399元','1399元','800元','1200元','1250元']})
df
商品名称 出售日期 价格
0 荣耀9青春版 2017.05.25 999元
1 小米6x 2017.05.25 1399元
2 oppo al 2017.05.25 1399元
3 荣耀9青春版 2017.06.18 800元
4 小米6x 2017.06.18 1200元
5 oppo al 2017.06.18 1250元
df.pivot(index='出售日期',columns='商品名称',values='价格') #通过pivot进行轴向旋转
商品名称 oppo al 小米6x 荣耀9青春版
出售日期
2017.05.25 1399元 1399元 999元
2017.06.18 1250元 1200元 800元
数据转换
- 数据转换是指数据从一种表现形势变为另一种表现形势的过程，具体包括重命名轴索引，离散化和面元划分，计算指标/哑变量。
重命名轴索引
- rename():重命名个别列索引或行索引的标签或名称
- rename(napper=None,index=None,columns=None,axis=None,copy=True,inplace=False,level=None)
- index,columns:表示待转换的行索引和列索引
- axis：表示轴名称，可以使用index或columns，也可以使用0或1
- copy:表示是否复制底层的数据，默认为Flase
- inplace：默认为False，表示返回新的Pandas对象，如果设置为True，则会忽略复制的值
- level：表示级别名称，默认为None，对于多级索引，只重命名指定的标签
df = pd.DataFrame({'A':['A0','A1','A2','A3'], #原数据
'B':['B0','B1','B2','B3'],
'C':['C0','C1','C2','C3']})
df
A B C
0 A0 B0 C0
1 A1 B1 C1
2 A2 B2 C2
3 A3 B3 C3
df.rename(columns={'A':'a','B':'b','C':'c'}) #使用rename修改列索引
a b c
0 A0 B0 C0
1 A1 B1 C1
2 A2 B2 C2
3 A3 B3 C3
df.rename(str.lower,axis='columns') #使用str内置函数直接变小写
a b c
0 A0 B0 C0
1 A1 B1 C1
2 A2 B2 C2
3 A3 B3 C3
df.rename(index={0:'a',1:'b'}) #使用rename修改行索引
A B C
a A0 B0 C0
b A1 B1 C1
2 A2 B2 C2
3 A3 B3 C3
离散化连续数据
- 有时我们会碰到这样的需求，例如，将有关年龄的数据进行离散化或拆分为’面元’,直白来说就是将年龄分为几个区间，pandas的cut()函数能够实现离散化操作，该函数的语法如下：
- pandas.cut(x,bins,right=True,labels=None,retbins=False,precision=3,include_lowest=False,duplicates=‘raise’)
- x:表示要分箱的数组，必须是一维的
- bins:接收int和序列类型的数据，如果传入的是int类型的值，则表示在x范围内的等宽单元的数量(划分为多少个等间距区)；如果传入的是一个序列，则表示将x划分在指定的序列中，若不在此序列中，则为NaN
- right：是否包含右端点，决定区间的开闭，默认为True
- labels: 用于生成区间的标签
- retbins:是否返回bin
- precision:精度，默认保存三位小数
- include_lowest：是否包含左端点
- cut()函数会返回一个Categorical对象，我们可以看作一组便是面元名称的字符串，它包含了分组数量以及不同分类的名称
ages = [20,22,25,27,21,23,37,31,61,45,32]
bins = [0,18,25,35,60,100]
cuts = pd.cut(ages,bins)
cuts
[(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], ..., (35, 60], (25, 35], (60, 100], (35, 60], (25, 35]]
Length: 11
Categories (5, interval[int64]): [(0, 18] < (18, 25] < (25, 35] < (35, 60] < (60, 100]]
#如果希望左闭右开区间，则可以在调用cut()函数时传入right=Flase进行修改
pd.cut(ages,bins,right=True)
[(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], ..., (35, 60], (25, 35], (60, 100], (35, 60], (25, 35]]
Length: 11
Categories (5, interval[int64]): [(0, 18] < (18, 25] < (25, 35] < (35, 60] < (60, 100]]
哑变量处理类别型数据
- 哑变量又称虚拟变量、名义变量，是人为虚设的变量用来反映某个变量的不同类别，使用哑变量处理数据就是将分类变量转换为哑变量矩阵或指标矩阵，矩阵的值通常用0或1表示。在pandas中可以用get_dummies()
- pd.get_dummies(
data,
prefix=None,
prefix_sep=’_’,
dummy_na=False,
columns=None,
sparse=False,
drop_first=False,
dtype=None,
) - data, # 可接收数组，DF，Series对象，表示哑变量处理的数据
- prefix=None, #表示列名的前缀，默认为None
- prefix_sep=’’, #用于附加前缀作为分割符使用，默认为’’
- dummy_na=False, # 表示是否为nan值添加一列
- columns=None, # 表示DF要编码的列名，默认为none
- sparse=False, # 表示虚拟列是否稀疏
- drop_first=False, #是否通过从k个分类级别中删除第一个级来获取k-1个分类级别，默认为False
- dtype=None,
df1 = pd.DataFrame({'职业':['学生','司机','老师','导游']})
df1
职业
0 学生
1 司机
2 老师
3 导游
_
pd.get_dummies(df1,prefix=['col_'])
col__司机 col__学生 col__导游 col__老师
0 0 1 0 0
1 1 0 0 0
2 0 0 0 1
3 0 0 1 0