码迷,mamicode.com
首页 > 编程语言 > 详细

利用python 进行数据清洗

时间:2019-11-21 09:17:17      阅读:66      评论:0      收藏:0      [点我收藏+]

标签:evel   输入   copy   ica   pandas   war   重复   格式化   种子   

import pandas as pd
data.to_csv("路径",encoding=utf-8) 保存文件
data.head() 查看前几行
data.tail() 查看后几行
data.shape  几行几列
data.index  查看索引
data.columns 查看标题
data.values  查看值
data.info    查看整体结构
data.describe() 对数值型数据进行描述统计
data.value_counts()对值计数
data.sort_index(axis=1/0)  对索引进行排序 参数ascending=False 降序排序
data.sort_calues(by="columens") 按照某一行的值进行排序 inplace=True 修改原始数据
选取数据
data.columns
data["cloumns"]
data.loc[] 显示索引
data.iloc[] 隐示索引

## 映射函数 data.apply()

#data.apply(abs) 将abs作用于data的每一个数据
data=pd.Series([1,-2,3,-3],index=["a","b","c","d"])
data.apply(abs)
Out[6]:
a    1
b    2
c    3
d    3
dtype: int64
In [ ]:
data.iloc[[0,2],data.columns.get_loc("one")] 混合索引 0-2 行 one列
data.iloc[[0,2],data.columns.get_indexer(["one","tow"])] 同时得到2列
 布尔型索引
In [ ]:
布儿型索引
| 代表 or  & 代表 and   -代表not
data[(df.one>0)&(df.two>0)]
data[(df.one>0)|(df.two>0)]
data[(df.one>0)-(df.two>0)]
用与筛选需要的子集
In [9]:
import numpy as np
ser=pd.Series(np.arange(5),index=np.arange(5)[::-1],dtype="int32")
ser
Out[9]:
4    0
3    1
2    2
1    3
0    4
dtype: int32
In [10]:
ser.isin([2,3,4])#查看是否存在 2,3,4
Out[10]:
4    False
3    False
2     True
1     True
0     True
dtype: bool
 

sample(),方法随机抽样

In [11]:
###随机抽样
sample()方法从Series或者DataFriame中随机选择行或列
ser.sample()
参数 n
=None, #抽取多少个 frac=None, #抽取多少比列 replace=False, #是否为有放回抽样 weights=None, #设定每一行的权重 random_state=None, #是否需要重现随机的结果,设置随机数种子 axis=None # 设定是对行采样还是对列采样
In [12]:
ser=pd.Series([1,2,3,4,5])
ser
Out[12]:
0    1
1    2
2    3
3    4
4    5
dtype: int64
In [13]:
ser.sample()#默认抽取一个
Out[13]:
0    1
dtype: int64
In [14]:
ser.sample(4)#默认抽取4个
Out[14]:
0    1
2    3
4    5
3    4
dtype: int64
In [15]:
ser.sample(frac=0.8)#抽取80%
Out[15]:
3    4
1    2
0    1
2    3
dtype: int64
In [16]:
#不加参数默认进行不放回抽样,使用replace 替换抽样方式
ser.sample(n=5,replace=False)# 不放回
Out[16]:
3    4
0    1
2    3
1    2
4    5
dtype: int64
In [17]:
ser.sample(n=5,replace=True)#有放回
Out[17]:
0    1
4    5
3    4
3    4
2    3
dtype: int64
In [24]:
ser_weight=[0.1,0.2,0.2,0.3,0.4]
ser.sample(n=4,weights=ser_weight )   
#总体权重和为1 如果输入的值不为一,会从新归一化
Out[24]:
3    4
4    5
0    1
2    3
dtype: int64
In [25]:
#在采样中,会用DataFrame的某一列作为权重
df=pd.DataFrame({"first":[4,5,6,7],"weight_column":[0.3,0.4,0.2,0.1]})
df
Out[25]:
 firstweight_column
0 4 0.3
1 5 0.4
2 6 0.2
3 7 0.1
In [27]:
 
df.sample(n=2,weights="weight_column")
 
Out[27]:
 firstweight_column
2 6 0.2
1 5 0.4
In [29]:
 df.sample(n=2,axis=1)
 
Out[29]:
 weight_columnfirst
0 0.3 4
1 0.4 5
2 0.2 6
3 0.1 7
In [32]:
df.sample(n=2,random_state=2)
 
Out[32]:
 firstweight_column
2 6 0.2
3 7 0.1
In [33]:
 
?df.sample
 

数据合并

In [39]:
df1=pd.DataFrame({"A":["A0","A1","A2","A3"],"B":["B0","B1","B2","B3"],
"C":["C0","C1","C2","C3"],
"D":["D0","D1","D2","D3"]},index=[0,1,2,3])
df2=pd.DataFrame({"A":["A0","A1","A2","A3"],"B":["B0","B1","B2","B3"],
"C":["C0","C1","C2","C3"],
"D":["D0","D1","D2","D3"]},index=[4,5,6,7])
df3=pd.DataFrame({"A":["A0","A1","A2","A3"],"B":["B0","B1","B2","B3"],
"C":["C0","C1","C2","C3"],
"D":["D0","D1","D2","D3"]},index=[8,9,10,11])

In [41]:

print(df1);print(df2);print(df3)
    A   B   C   D
0  A0  B0  C0  D0
1  A1  B1  C1  D1
2  A2  B2  C2  D2
3  A3  B3  C3  D3
    A   B   C   D
4  A0  B0  C0  D0
5  A1  B1  C1  D1
6  A2  B2  C2  D2
7  A3  B3  C3  D3
     A   B   C   D
8   A0  B0  C0  D0
9   A1  B1  C1  D1
10  A2  B2  C2  D2
11  A3  B3  C3  D3
 

用pd。concat()合并数据

In [ ]:
###用pd.concat()合并对象
参数
pd.concat()
objs,  数据集
axis=0,  轴线 默认0
join=outer,  连接方式 inner outer
join_axes=None, 用指定的轴进行合并
ignore_index=False,都合并没有就不合并 /True 根据列字段对齐合并,生成新的索引
keys=None, 指定不同数据源
levels=None, 
names=None, 
verify_integrity=False, 
copy=True)
In [43]:
pd.concat([df1,df2,df3])#列合并
Out[43]:
 ABCD
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 A0 B0 C0 D0
5 A1 B1 C1 D1
6 A2 B2 C2 D2
7 A3 B3 C3 D3
8 A0 B0 C0 D0
9 A1 B1 C1 D1
10 A2 B2 C2 D2
11 A3 B3 C3 D3
In [45]:
 
df4=pd.DataFrame({"B":["B0","B1","B2","B3"],
"C":["C0","C1","C2","C3"],
"E":["E0","E1","E4","E5"]},index=[0,1,4,5])
df4
Out[45]:
 BCE
0 B0 C0 E0
1 B1 C1 E1
4 B2 C2 E4
5 B3 C3 E5
In [46]:
pd.concat([df1,df4],axis=1)#横向合并
 
Out[46]:
 ABCDBCE
0 A0 B0 C0 D0 B0 C0 E0
1 A1 B1 C1 D1 B1 C1 E1
2 A2 B2 C2 D2 NaN NaN NaN
3 A3 B3 C3 D3 NaN NaN NaN
4 NaN NaN NaN NaN B2 C2 E4
5 NaN NaN NaN NaN B3 C3 E5
In [47]:
pd.concat([df1,df4],axis=1,join="inner")#取交集
Out[47]:
 ABCDBCE
0 A0 B0 C0 D0 B0 C0 E0
1 A1 B1 C1 D1 B1 C1 E1
In [49]:
pd.concat([df1,df4],axis=1,join_axes=[df1.index])#指定合并的轴
Out[49]:
 ABCDBCE
0 A0 B0 C0 D0 B0 C0 E0
1 A1 B1 C1 D1 B1 C1 E1
2 A2 B2 C2 D2 NaN NaN NaN
3 A3 B3 C3 D3 NaN NaN NaN
In [52]:
 pd.concat([df1,df4],ignore_index=False)
Out[52]:
 ABCDE
0 A0 B0 C0 D0 NaN
1 A1 B1 C1 D1 NaN
2 A2 B2 C2 D2 NaN
3 A3 B3 C3 D3 NaN
0 NaN B0 C0 NaN E0
1 NaN B1 C1 NaN E1
4 NaN B2 C2 NaN E4
5 NaN B3 C3 NaN E5
In [53]:
 pd.concat([df1,df4],ignore_index=True)#生成新的index

Out[53]:

 ABCDE
0 A0 B0 C0 D0 NaN
1 A1 B1 C1 D1 NaN
2 A2 B2 C2 D2 NaN
3 A3 B3 C3 D3 NaN
4 NaN B0 C0 NaN E0
5 NaN B1 C1 NaN E1
6 NaN B2 C2 NaN E4
7 NaN B3 C3 NaN E5
In [54]:
ser=pd.Series(["s0","s1","s2","s3"],name="s")
ser
Out[54]:
0    s0
1    s1
2    s2
3    s3
Name: s, dtype: object
In [56]:
pd.concat([df1,ser],axis=1)#合并之后Series的名称自动成为列名称,不指定name自动生成
Out[56]:
 ABCDs
0 A0 B0 C0 D0 s0
1 A1 B1 C1 D1 s1
2 A2 B2 C2 D2 s2
3 A3 B3 C3 D3 s3
In [61]:
pd.concat([df1,df2,df3],keys=["one","two","three"])#区分不同的数据来源
Out[61]:
  ABCD
one0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
two4 A0 B0 C0 D0
5 A1 B1 C1 D1
6 A2 B2 C2 D2
7 A3 B3 C3 D3
three8 A0 B0 C0 D0
9 A1 B1 C1 D1
10 A2 B2 C2 D2
11 A3 B3 C3 D3
In [60]:
data=pd.concat([df1,df2,df3])
dic={"one":df1,"two":df2,"three":df3}
pd.concat(dic) #也可以区分不同的数据集
 
Out[60]:
  ABCD
one0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
three8 A0 B0 C0 D0
9 A1 B1 C1 D1
10 A2 B2 C2 D2
11 A3 B3 C3 D3
two4 A0 B0 C0 D0
5 A1 B1 C1 D1
6 A2 B2 C2 D2
7 A3 B3 C3 D3
 

用append 实现合并

In [ ]:
df.append()
 [63]:
df1.append(df4)
Out[63]:
 ABCDE
0 A0 B0 C0 D0 NaN
1 A1 B1 C1 D1 NaN
2 A2 B2 C2 D2 NaN
3 A3 B3 C3 D3 NaN
0 NaN B0 C0 NaN E0
1 NaN B1 C1 NaN E1
4 NaN B2 C2 NaN E4
5 NaN B3 C3 NaN E5
In [64]:
 
df1.append([df2,df3])
Out[64]:
 ABCD
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 A0 B0 C0 D0
5 A1 B1 C1 D1
6 A2 B2 C2 D2
7 A3 B3 C3 D3
8 A0 B0 C0 D0
9 A1 B1 C1 D1
10 A2 B2 C2 D2
11 A3 B3 C3 D3
 

#用append方法添加新行

In [65]:
ser3=pd.Series(["q1","q2","q3","q4"],index=["A","B","C","D"])
ser3
Out[65]:
A    q1
B    q2
C    q3
D    q4
dtype: object
In [67]:
df1.append(ser3,ignore_index=True)
Out[67]:
 ABCD
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 q1 q2 q3 q4
 

pandas 数据清洗案列

In [71]:
import pandas as pd
1.数据的读取
In [84]:
df=pd.read_csv("taobao.csv",encoding="gbk")
df.head()
Out[84]:
 宝贝价格成交量位置品牌
0 母亲节衣服夏季中年女装连衣裙中长款裙子中老年妈妈装夏装40岁50 148.0 9276 浙江 嘉兴 浅恋
1 中年女夏装40-50岁中老年女装妈妈装雪纺连衣裙短袖中长款裙子 129.0 3593 浙江 杭州 缘福
2 母亲节衣服夏季中年女装夏装短袖40-50岁妈妈装中老年女装连衣裙 59.0 18569 江苏 苏州 洛妃
3 中老年女装夏装连衣裙中年雪纺上衣妈妈装中长款40-50岁大码裙子 38.8 10296 上海 NaN
4 妈妈夏装套装40岁中老年女装春装中年连衣裙两件套母亲节衣服夏季 128.0 13313 江苏 苏州 孔雀
In [86]:
df.tail(10)
Out[86]:
 宝贝价格成交量位置品牌
421 中年女夏装2017新款40-50岁妈妈装夏天短袖中长款雪纺连衣裙宽松 89.0 439 浙江 嘉兴 佳人
422 母亲节中年妈妈夏装连衣裙大码中老年春夏季上衣服女雪纺裙40岁50 138.0 118 湖北 武汉 恋慈
423 母亲节衣服中年妈妈雪纺连衣裙中老年大码女装夏天中长款裙子40岁 36.0 817 江苏 苏州 NaN
424 春装结婚宴婚庆妈妈装蕾丝连衣裙夏季大码女装宴会喜庆婆婆婚礼服 218.0 525 广东 东莞 兰香
425 中年假两件套夏季妈妈装女装印花夏天雪纺连衣裙短袖30-40-50岁 129.0 96 北京 other/其他
426 中老年女装夏装连衣裙中长款打底衫女40-50岁中年妈妈装短袖裙子 39.9 535 江苏 苏州 NaN
427 天天特价中老年春夏新款真丝大码短袖中长款连衣裙修身百褶裙女装 89.0 1416 广东 广州 NaN
428 2017夏季新款优雅印花真丝连衣裙中长款短袖桑蚕丝宽松大码中老年 349.0 284 浙江 杭州 YL-TianRui/睿
429 2017春装妈妈装新款中老年女装蕾丝连衣裙中长款裙子母亲节衣服夏 78.0 313 江苏 苏州
430 中老年女装蕾丝夏装妈妈装连衣裙上衣中年女大码宽松刺绣短袖T恤 48.0 688 江苏 苏州 other/其他
 

2.快速探索

In [87]:
df.info()
Out[88]:
<class ‘pandas.core.frame.DataFrame‘>
RangeIndex: 431 entries, 0 to 430
Data columns (total 5 columns):
宝贝     431 non-null object
价格     431 non-null float64
成交量    431 non-null int64
位置     431 non-null object
品牌     349 non-null object
dtypes: float64(1), int64(1), object(3)
memory usage: 16.9+ KB
In [88]:
#查看描述统计信息
df.describe()

 

Out[88]:
 价格成交量
count 431.000000 431.000000
mean 133.149977 1545.044084
std 85.433711 1901.357985
min 14.900000 80.000000
25% 89.000000 438.000000
50% 128.000000 919.000000
75% 158.000000 1894.500000
max 866.000000 18569.000000
 

3.数据的选择

In [90]:
#行的选择
df[0:5]
df.iloc[0:5]
Out[90]:
 宝贝价格成交量位置品牌
0 母亲节衣服夏季中年女装连衣裙中长款裙子中老年妈妈装夏装40岁50 148.0 9276 浙江 嘉兴
1 中年女夏装40-50岁中老年女装妈妈装雪纺连衣裙短袖中长款裙子 129.0 3593 浙江 杭州 缘福
2 母亲节衣服夏季中年女装夏装短袖40-50岁妈妈装中老年女装连衣裙 59.0 18569 江苏 苏州 pllo洛妃
3 中老年女装夏装连衣裙中年雪纺上衣妈妈装中长款40-50岁大码裙子 38.8 10296 上海 NaN
4 妈妈夏装套装40岁中老年女装春装中年连衣裙两件套母亲节衣服夏季 128.0 13313 江苏 苏州 孔雀
In [91]:
#列的选择
cols=df[["宝贝","价格"]]
type(cols)
cols.head()
cols=df[["宝贝","价格"]].head()#数据太多读取太慢,可选择只查看多少行
cols
Out[91]:
 宝贝价格
0 母亲节衣服夏季中年女装连衣裙中长款裙子中老年妈妈装夏装40岁50 148.0
1 中年女夏装40-50岁中老年女装妈妈装雪纺连衣裙短袖中长款裙子 129.0
2 母亲节衣服夏季中年女装夏装短袖40-50岁妈妈装中老年女装连衣裙 59.0
3 中老年女装夏装连衣裙中年雪纺上衣妈妈装中长款40-50岁大码裙子 38.8
4 妈妈夏装套装40岁中老年女装春装中年连衣裙两件套母亲节衣服夏季 128.0
In [95]:
#区域的选择
df.loc[0:3,["宝贝","价格"]]
df.loc[df.index[0:3],["宝贝","价格"]]
Out[95]:
 宝贝价格
0 母亲节衣服夏季中年女装连衣裙中长款裙子中老年妈妈装夏装40岁50 148.0
1 中年女夏装40-50岁中老年女装妈妈装雪纺连衣裙短袖中长款裙子 129.0
2 母亲节衣服夏季中年女装夏装短袖40-50岁妈妈装中老年女装连衣裙 59.0
 

4.数据的整理

In [96]:
df["销售额"]=df["价格"]*df["成交量"]
df.head()
Out[96]:
 宝贝价格成交量位置品牌销售额
0 母亲节衣服夏季中年女装连衣裙中长款裙子中老年妈妈装夏装40岁50 148.0 9276 浙江 嘉兴 1372848.0
1 中年女夏装40-50岁中老年女装妈妈装雪纺连衣裙短袖中长款裙子 129.0 3593 浙江 杭州 缘福 463497.0
2 母亲节衣服夏季中年女装夏装短袖40-50岁妈妈装中老年女装连衣裙 59.0 18569 江苏 苏州 pllofee/洛妃 1095571.0
3 中老年女装夏装连衣裙中年雪纺上衣妈妈装中长款40-50岁大码裙子 38.8 10296 上海 NaN 399484.8
4 妈妈夏装套装40岁中老年女装春装中年连衣裙两件套母亲节衣服夏季 128.0 13313 江苏 苏州 孔雀 1704064.0
In [102]:
#过滤掉价格>=100,成交量<8000的商品信息
df[(df["价格"]<100)&(df["成交量"]>=8000)]
Out[102]:
 宝贝价格成交量位置品牌销售额
2 母亲节衣服夏季中年女装夏装短袖40-50岁妈妈装中老年女装连衣裙 59.0 18569 江苏 苏州 pllofe洛妃 1095571.0
3 中老年女装夏装连衣裙中年雪纺上衣妈妈装中长款40-50岁大码裙子 38.8 10296 上海 NaN 399484.8
5 新款妈妈装连衣裙中长款短袖夏装中年妇女40-50大码气质打底裙子 37.8 8844 北京 玛依 334303.2
7 妈妈夏装套装女40-50岁上衣2017新款时尚两件套中老年春装连衣裙 98.0 8494 浙江 嘉兴 锦蒂 832412.0
In [105]:
#将位置设置为索引
#df.index=df["位置"]
df1=df.set_index("位置")
df1.head()
Out[105]:
 宝贝价格成交量品牌销售额
位置     
浙江 嘉兴 母亲节衣服夏季中年女装连衣裙中长款裙子中老年妈妈装夏装40岁50 148.0 9276 1372848.0
浙江 杭州 中年女夏装40-50岁中老年女装妈妈装雪纺连衣裙短袖中长款裙子 129.0 3593 缘福 463497.0
江苏 苏州 母亲节衣服夏季中年女装夏装短袖40-50岁妈妈装中老年女装连衣裙 59.0 18569 p洛妃 1095571.0
上海 中老年女装夏装连衣裙中年雪纺上衣妈妈装中长款40-50岁大码裙子 38.8 10296 NaN 399484.8
江苏 苏州 妈妈夏装套装40岁中老年女装春装中年连衣裙两件套母亲节衣服夏季 128.0 13313 孔雀 1704064.0
In [106]:
#排序
df2=df1.sort_index()
df2.head()
Out[106]:
 宝贝价格成交量品牌销售额
位置     
上海 乐卡索妈妈装春装中袖中年女装大花纯色打底中老年夏季大码连衣裙 179.0 866 卡索 155014.0
上海 乐卡索妈妈装夏装连衣裙大花雪纺裙中老年女装40岁中年裙大码裙子 139.0 1371 卡索 190569.0
上海 中老年女装夏装连衣裙40-50岁中年妈妈装雪纺长裙老年人大码裙子 69.0 2663 183747.0
上海 2017中年高档参加婚礼妈妈装春夏连衣裙高贵新娘喜婆婆结婚宴礼服 458.0 441 other/其他 201978.0
上海 2017新款妈妈装夏装短袖连衣裙蕾丝中长款4050岁中年女装夏季裙子 138.0 461 NaN 63618.0
In [113]:
#两个索引
df3=df.set_index(["位置","品牌"])
df3.head()
#并根据位置进行排序
#df4=df3.sort_index(level=0)
df4=df3.sort_index(level="位置")
df4.head()
Out[113]:
  宝贝价格成交量销售额
位置品牌    
上海NaN 中老年女装夏装连衣裙中年雪纺上衣妈妈装中长款40-50岁大码裙子 38.8 10296 399484.8
NaN 2017新款妈妈装夏装短袖连衣裙蕾丝中长款4050岁中年女装夏季裙子 138.0 461 63618.0
other/其他 2017中年高档参加婚礼妈妈装春夏连衣裙高贵新娘喜婆婆结婚宴礼服 458.0 441 201978.0
other/其他 2017春夏新款参加婚礼妈妈装连衣裙婚宴婆婆喜庆中老年结婚礼服 398.0 410 163180.0
乐卡索 乐卡索妈妈装夏装连衣裙大花雪纺裙中老年女装40岁中年裙大码裙子 139.0 1371 190569.0
 

groupby 分组汇总

In [126]:
#删除不需要的数据
deal=df.drop(["宝贝","品牌","位置"],axis=1)
deal.head()
#inplace=Fals 不修改原始数据   True 修改原始数据
Out[126]:
 价格成交量销售额
位置   
浙江 嘉兴 148.0 9276 1372848.0
浙江 杭州 129.0 3593 463497.0
江苏 苏州 59.0 18569 1095571.0
上海 38.8 10296 399484.8
江苏 苏州 128.0 13313 1704064.0
In [127]:
deal.groupby("位置").mean()#均值
Out[127]:
 价格成交量销售额
位置   
上海 181.715385 1808.307692 187735.600000
北京 105.395158 1431.463158 108372.716632
安徽 芜湖 729.000000 148.000000 107892.000000
山东 济南 155.857143 1566.000000 250650.857143
广东 东莞 164.777778 826.000000 137011.333333
广东 广州 251.909091 635.090909 89932.181818
广东 深圳 178.214286 1058.142857 151225.928571
江苏 无锡 125.675000 1963.500000 197929.475000
江苏 苏州 100.697297 1750.261261 170828.847748
河南 商丘 178.000000 216.000000 38448.000000
河南 郑州 68.000000 486.000000 33048.000000
浙江 嘉兴 136.185000 1760.400000 230214.150000
浙江 宁波 153.750000 1888.000000 270564.750000
浙江 杭州 190.150000 1534.423077 236328.896154
浙江 绍兴 380.000000 375.000000 142500.000000
浙江 金华 218.000000 1241.333333 273324.000000
湖北 武汉 140.600000 1417.200000 211603.960000
In [128]:
df["成交量"].groupby(df["位置"]).mean()
Out[128]:
位置
上海       1808.307692
北京       1431.463158
安徽 芜湖     148.000000
山东 济南    1566.000000
广东 东莞     826.000000
广东 广州     635.090909
广东 深圳    1058.142857
江苏 无锡    1963.500000
江苏 苏州    1750.261261
河南 商丘     216.000000
河南 郑州     486.000000
浙江 嘉兴    1760.400000
浙江 宁波    1888.000000
浙江 杭州    1534.423077
浙江 绍兴     375.000000
浙江 金华    1241.333333
湖北 武汉    1417.200000
Name: 成交量, dtype: float64
In [130]:
df["成交量"].groupby([df["位置"],df["品牌"]]).mean()
#按多组列进行分组
Out[130]:
位置     品牌                  
上海     other/其他                 425.500000
       卡索                     1155.750000
       千恋                   1191.000000
       茹                      1408.000000
       港                      2663.000000
       熟了                     824.000000
北京     斯岩                  2699.000000
       COOKBOOK                 541.000000
       夫人        1146.000000
       黑茉莉      559.000000
       利达         834.000000
       LIGGCOK                  550.500000
       SNOWQUEEN                272.000000
       other/其他                1624.600000
       songmay                  106.000000
       乐姿                     2174.000000
       菲玛依                    4335.666667
       城秀                      316.000000
       璐                       780.000000
       寒斯                      237.000000
       巧尔                      372.000000
       欣诺                     3497.000000
       爱雪                      738.500000
       爱悦                     768.000000
       甘人                      327.000000
       秋涵                      749.000000
       港                       508.000000
       简蓉                      541.000000
       紫媛                      722.000000
       羽佩                       451.000000
                                  ...     
浙江 金华  Honra莱妃             970.000000
       Loui瑞芙           1377.000000
湖北 武汉  Choph芙丽         955.500000
       ESILEE夫人         256.000000
       FIR索尔            940.500000
       OUM薇              229.000000
Name: 成交量, Length: 211, dtype: float64
 

5.数据合并

In [132]:
#创建数据
df1=df[20:30][["位置","品牌"]]
df1.head()
Out[132]:
 位置品牌
位置  
江苏 苏州 江苏 苏州 NaN
浙江 嘉兴 浙江 嘉兴 NaN
江苏 苏州 江苏 苏州 孔雀
江苏 苏州 江苏 苏州 NaN
浙江 嘉兴 浙江 嘉兴 DUO莹
In [133]:
df2=df[25:35][["品牌","价格","成交量"]]
df2.head()
Out[133]:
 品牌价格成交量
位置   
浙江 嘉兴 浅恋 128.0 6787
江苏 苏州 NaN 69.0 6501
江苏 苏州 芬典 168.0 5967
北京 NaN 39.0 4241
北京 NaN 49.0 3996
In [135]:
df2.info()
<class ‘pandas.core.frame.DataFrame‘>
Index: 10 entries, 浙江 嘉兴 to 北京
Data columns (total 3 columns):
品牌     7 non-null object
价格     10 non-null float64
成交量    10 non-null int64
dtypes: float64(1), int64(1), object(1)
memory usage: 320.0+ bytes
In [136]:
#pd.merge 根据一个或多个KEY值,将DataFrame连接(join)
#pd.concat 沿着一个轴拼接
#combine_first 如果有缺失值,另外要给数据集对其进行填充
In [143]:
pd.merge(df1,df2).head()
 Out[143]:
 位置品牌价格成交量
0 江苏 苏州 NaN 69.0 6501
1 江苏 苏州 NaN 39.0 4241
2 江苏 苏州 NaN 49.0 3996
3 浙江 嘉兴 NaN 69.0 6501
4 浙江 嘉兴 NaN 39.0 4241
In [142]:
pd.merge(df1,df2,how="outer").head()#how默认为 inner 可修改为 outer left right
Out[142]:
 位置品牌价格成交量
0 江苏 苏州 NaN 69.0 6501.0
1 江苏 苏州 NaN 39.0 4241.0
2 江苏 苏州 NaN 49.0 3996.0
3 浙江 嘉兴 NaN 69.0 6501.0
4 浙江 嘉兴 NaN 39.0 4241.0
In [145]:
#索引合并
pd.merge(df2,df1,left_index=True,right_index=True).head()
Out[145]:
 品牌_x价格成交量位置品牌_y
位置     
北京 NaN 39.0 4241 北京 NaN
北京 NaN 39.0 4241 北京 NaN
北京 NaN 49.0 3996 北京 NaN
北京 NaN 49.0 3996 北京 NaN
北京 other/其他 15.8 2596 北京 NaN
 

6.数据重塑

 

DataFrame 创建数据是无序的

In [2]:
import pandas as pd
df=pd.DataFrame({"日期":["2017-01-01","2017-01-02","2017-01-03","2017-02-03","2017-02-04","2017-03-01","2017-03-02"],"最高气温":
[12,13,14,15,16,17,15],"最低气温":[7,8,8,9,12,3,5],"天气":["","多云","多云","小雨","小雨","",""],"风向":
["西北风","东北风","东北风","西北风","西北风","北风","南风"],"风力":[2,2,2,1,2,3,2]})
reindex 可对DataFrame 进行排序
In [157]:
df=df.reindex(["日期"]+["最高气温"]+["最低气温"]+["天气"]+["风向"]+["风力"],axis=1)
df.head()
Out[157]:
 日期最高气温最低气温天气风向风力
0 2017-01-01 12 7 西北风 2
1 2017-01-02 13 8 多云 东北风 2
2 2017-01-03 14 8 多云 东北风 2
3 2017-02-03 15 9 小雨 西北风 1
4 2017-02-04 16 12 小雨 西北风 2
In [160]:
df.stack()#列转化为层级的Series
Out[160]:
0  日期      2017-01-01
   最高气温            12
   最低气温             7
   天气               晴
   风向             西北风
   风力               2
1  日期      2017-01-02
   最高气温            13
   最低气温             8
   天气              多云
   风向             东北风
   风力               2
2  日期      2017-01-03
   最高气温            14
   最低气温             8
   天气              多云
   风向             东北风
   风力               2
3  日期      2017-02-03
   最高气温            15
   最低气温             9
   天气              小雨
   风向             西北风
   风力               1
4  日期      2017-02-04
   最高气温            16
   最低气温            12
   天气              小雨
   风向             西北风
   风力               2
5  日期      2017-03-01
   最高气温            17
   最低气温             3
   天气               晴
   风向              北风
   风力               3
6  日期      2017-03-02
   最高气温            15
   最低气温             5
   天气               阴
   风向              南风
   风力               2
dtype: object
In [161]:
df.stack().unstack()#还原
Out[161]:
 日期最高气温最低气温天气风向风力
0 2017-01-01 12 7 西北风 2
1 2017-01-02 13 8 多云 东北风 2
2 2017-01-03 14 8 多云 东北风 2
3 2017-02-03 15 9 小雨 西北风 1
4 2017-02-04 16 12 小雨 西北风 2
5 2017-03-01 17 3 北风 3
6 2017-03-02 15 5 南风 2
 

数据透视表

In [ ]:
pd.pivot_table()
data,  数据集
values=None, 值是谁
index=None,  索引是谁
columns=None, 标题是谁
aggfunc=mean, 聚合的函数是谁
fill_value=None, 
margins=False, 
dropna=True,   是否召回
margins_name=All
In [164]:
df_table=pd.pivot_table(df,index=["天气"],columns=["风向"],values=["最高气温"])
df_table
 Out[164]:
 最高气温
风向东北风北风南风西北风
天气    
多云 13.5 NaN NaN NaN
小雨 NaN NaN NaN 15.5
NaN 17.0 NaN 12.0
NaN NaN 15.0 NaN
In [165]:
df_table.info()
<class ‘pandas.core.frame.DataFrame‘>
Index: 4 entries, 多云 to 阴
Data columns (total 4 columns):
(最高气温, 东北风)    1 non-null float64
(最高气温, 北风)     1 non-null float64
(最高气温, 南风)     1 non-null float64
(最高气温, 西北风)    2 non-null float64
dtypes: float64(4)
memory usage: 160.0+ bytes
In [3]:
import numpy as np
In [4]:
 df=pd.DataFrame({"日期":["2017-01-01","2017-01-02","2017-01-03","2017-02-03","2017-02-04","2017-03-01","2017-03-02"],"最高气温":
[12,13,14,15,np.nan,17,15],"最低气温":[7,8,8,np.nan,12,3,5],"天气":[np.nan,"多云","多云","小雨","小雨","",""],"风向":
["西北风",np.nan,"东北风","西北风",np.nan,"北风","南风"],"风力":[2,2,np.nan,1,2,3,2]})
In [5]:
df
Out[5]:
 天气日期最低气温最高气温风力风向
0 NaN 2017-01-01 7.0 12.0 2.0 西北风
1 多云 2017-01-02 8.0 13.0 2.0 NaN
2 多云 2017-01-03 8.0 14.0 NaN 东北风
3 小雨 2017-02-03 NaN 15.0 1.0 西北风
4 小雨 2017-02-04 12.0 NaN 2.0 NaN
5 2017-03-01 3.0 17.0 3.0 北风
6 2017-03-02 5.0 15.0 2.0 南风
 

缺失值的处理

In [7]:
df.isnull()#发现缺失值 True 为有缺失
Out[7]:
 天气日期最低气温最高气温风力风向
0 True False False False False False
1 False False False False False True
2 False False False False True False
3 False False True False False False
4 False False False True False True
5 False False False False False False
6 False False False False False False
In [9]:
df.notnull()#发现缺失值 False 为有缺失
Out[9]:
 天气日期最低气温最高气温风力风向
0 False True True True True True
1 True True True True True False
2 True True True True False True
3 True True False True True True
4 True True True False True False
5 True True True True True True
6 True True True True True True
In [10]:
 
df.dropna(axis=0) 删除有缺失值的行
Out[10]:
 天气日期最低气温最高气温风力风向
5 2017-03-01 3.0 17.0 3.0 北风
6 2017-03-02 5.0 15.0 2.0 南风
In [11]:
df.dropna(axis=1)#删除有缺失值的列
Out[11]:
 日期
0 2017-01-01
1 2017-01-02
2 2017-01-03
3 2017-02-03
4 2017-02-04
5 2017-03-01
6 2017-03-02
 

缺失值的填充

In [13]:
#用字符串填充
df.fillna("missing")
Out[13]:
 天气日期最低气温最高气温风力风向
0 missing 2017-01-01 7 12 2 西北风
1 多云 2017-01-02 8 13 2 missing
2 多云 2017-01-03 8 14 missing 东北风
3 小雨 2017-02-03 missing 15 1 西北风
4 小雨 2017-02-04 12 missing 2 missing
5 2017-03-01 3 17 3 北风
6 2017-03-02 5 15 2 南风
In [15]:
#使用前一个数值代替
df.fillna(method="pad")
Out[15]:
 天气日期最低气温最高气温风力风向
0 NaN 2017-01-01 7.0 12.0 2.0 西北风
1 多云 2017-01-02 8.0 13.0 2.0 西北风
2 多云 2017-01-03 8.0 14.0 2.0 东北风
3 小雨 2017-02-03 8.0 15.0 1.0 西北风
4 小雨 2017-02-04 12.0 15.0 2.0 西北风
5 2017-03-01 3.0 17.0 3.0 北风
6 2017-03-02 5.0 15.0 2.0 南风
In [16]:
df.fillna(method="pad",limit=1)#只向下或向上填充一个,填充过多数据不准
Out[16]:
 天气日期最低气温最高气温风力风向
0 NaN 2017-01-01 7.0 12.0 2.0 西北风
1 多云 2017-01-02 8.0 13.0 2.0 西北风
2 多云 2017-01-03 8.0 14.0 2.0 东北风
3 小雨 2017-02-03 8.0 15.0 1.0 西北风
4 小雨 2017-02-04 12.0 15.0 2.0 西北风
5 2017-03-01 3.0 17.0 3.0 北风
6 2017-03-02 5.0 15.0 2.0 南风
In [17]:
#向后填充
df.fillna(method="bfill")
Out[17]:
 天气日期最低气温最高气温风力风向
0 多云 2017-01-01 7.0 12.0 2.0 西北风
1 多云 2017-01-02 8.0 13.0 2.0 东北风
2 多云 2017-01-03 8.0 14.0 1.0 东北风
3 小雨 2017-02-03 12.0 15.0 1.0 西北风
4 小雨 2017-02-04 12.0 17.0 2.0 北风
5 2017-03-01 3.0 17.0 3.0 北风
6 2017-03-02 5.0 15.0 2.0 南风
In [18]:
#用均值填充
df.fillna(df.mean())
Out[18]:
 天气日期最低气温最高气温风力风向
0 NaN 2017-01-01 7.000000 12.000000 2.0 西北风
1 多云 2017-01-02 8.000000 13.000000 2.0 NaN
2 多云 2017-01-03 8.000000 14.000000 2.0 东北风
3 小雨 2017-02-03 7.166667 15.000000 1.0 西北风
4 小雨 2017-02-04 12.000000 14.333333 2.0 NaN
5 2017-03-01 3.000000 17.000000 3.0 北风
6 2017-03-02 5.000000 15.000000 2.0 南风
In [19]:
df.fillna(df.mean()["最低气温":"最高气温"])#只填充需要填充的行数
Out[19]:
 天气日期最低气温最高气温风力风向
0 NaN 2017-01-01 7.000000 12.000000 2.0 西北风
1 多云 2017-01-02 8.000000 13.000000 2.0 NaN
2 多云 2017-01-03 8.000000 14.000000 NaN 东北风
3 小雨 2017-02-03 7.166667 15.000000 1.0 西北风
4 小雨 2017-02-04 12.000000 14.333333 2.0 NaN
5 2017-03-01 3.000000 17.000000 3.0 北风
6 2017-03-02 5.000000 15.000000 2.0 南风
In [21]:
df.loc[:,"最低气温":"最高气温"].fillna(df.mean())
Out[21]:
 最低气温最高气温
0 7.000000 12.000000
1 8.000000 13.000000
2 8.000000 14.000000
3 7.166667 15.000000
4 12.000000 14.333333
5 3.000000 17.000000
6 5.000000 15.000000
 

检测和过滤异常值

In [24]:
#参照正太分布 定义》3标准差或小于-3标准差的值为异常值
sta=(df["最高气温"]-df["最高气温"].mean())/df["最高气温"].std()
sta.abs()>1
Out[24]:
0     True
1    False
2    False
3    False
4    False
5     True
6    False
Name: 最高气温, dtype: bool
In [40]:
df["最高温度是否异常"]=sta.abs()>1
df
Out[40]:
 天气日期最低气温最高气温风力风向最高温度是否异常
0 NaN 2017-01-01 7.0 12.0 2.0 西北风 True
1 多云 2017-01-02 8.0 13.0 2.0 NaN False
2 多云 2017-01-03 8.0 14.0 NaN 东北风 False
3 小雨 2017-02-03 NaN 15.0 1.0 西北风 False
4 小雨 2017-02-04 12.0 NaN 2.0 NaN False
5 2017-03-01 3.0 17.0 3.0 北风 True
6 2017-03-02 5.0 15.0 2.0 南风 False
In [41]:
df["最高温度是否异常"].value_counts()
Out[41]:
False    5
True     2
Name: 最高温度是否异常, dtype: int64
In [44]:
#用箱线图定义异常值
h=df["最高气温"]
iqr=h.quantile(0.75)-h.quantile(0.25)
df_max=h.quantile(0.75)+1.5*iqr
df_min=h.quantile(0.25)-1.5*iqr
 
In [45]:
df_max
Out[45]:
17.625
In [46]:
df_min
Out[46]:
10.625
In [52]:
df["isouter"]=(h>df_max)|(h<df_min)
In [53]:
df
Out[53]:
 天气日期最低气温最高气温风力风向最高温度是否异常isouter
0 NaN 2017-01-01 7.0 12.0 2.0 西北风 True False
1 多云 2017-01-02 8.0 13.0 2.0 NaN False False
2 多云 2017-01-03 8.0 14.0 NaN 东北风 False False
3 小雨 2017-02-03 NaN 15.0 1.0 西北风 False False
4 小雨 2017-02-04 12.0 NaN 2.0 NaN False False
5 2017-03-01 3.0 17.0 3.0 北风 True False
6 2017-03-02 5.0 15.0 2.0 南风 False False
 

重复值 duplicated

In [60]:
df.duplicated()
Out[60]:
0    False
1    False
2    False
3    False
4    False
5    False
6    False
dtype: bool
In [55]:
df.duplicated("风力")
Out[55]:
0    False
1     True
2    False
3    False
4     True
5    False
6     True
dtype: bool
In [57]:
d2=df.drop_duplicates("风力")#删除有重复项的行
In [59]:
d2
Out[59]:
 天气日期最低气温最高气温风力风向最高温度是否异常isouter
0 NaN 2017-01-01 7.0 12.0 2.0 西北风 True False
2 多云 2017-01-03 8.0 14.0 NaN 东北风 False False
3 小雨 2017-02-03 NaN 15.0 1.0 西北风 False False
5 2017-03-01 3.0 17.0 3.0 北风 True False
 

时间数据的处理

In [61]:
import time
 
In [62]:
time.time()#时间戳是指格林威治时间自1970年1月1日(00:00:00 gmy)至当前时间的总秒数
#北京时间1970年1月1日(08:00:00)
 Out[62]:
1572838472.6537158
In [63]:
time.localtime()
Out[63]:
time.struct_time(tm_year=2019, tm_mon=11, tm_mday=4, tm_hour=11, tm_min=38, tm_sec=45, tm_wday=0, tm_yday=308, tm_isdst=0)
 

时间格式的转换

In [ ]:
 
time.strftime()#format 时间格式
%Y  Year with century as a decimal number.
%m  Month as a decimal number [01,12].
%d  Day of the month as a decimal number [01,31].
%H  Hour (24-hour clock) as a decimal number [00,23].
%M  Minute as a decimal number [00,59].
%S  Second as a decimal number [00,61].
%z  Time zone offset from UTC.

%a  Locales abbreviated weekday name.
%A  Locales full weekday name.
%b  Locales abbreviated month name.
%B  Locales full month name.
%c  Locales appropriate date and time representation.
%I  Hour (12-hour clock) as a decimal number [01,12].
%p  Locales equivalent of either AM or PM.
time.strftime()格式化系统时间
In [64]:
time.strftime("%Y-%m-%d",time.localtime())#把当前时间转换成可读形式,注意转换之后为str格式
 Out[64]:
‘2019-11-04‘
In [66]:
s=time.strftime("%Y-%m-%d",time.localtime())
Out[66]:
‘2019-11-04‘
In [69]:
type(s)
Out[69]:
str
In [195]:
d=time.strptime(s,"%Y-%m-%d")#返回datetime格式的时间
Out[195]:
time.struct_time(tm_year=2019, tm_mon=11, tm_mday=4, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=308, tm_isdst=-1)
In [196]:
type(d)
Out[196]:
time.struct_time
 

将时间戳转换成系统时间

In [70]:
time.localtime(1533785557.0)
Out[70]:
time.struct_time(tm_year=2018, tm_mon=8, tm_mday=9, tm_hour=11, tm_min=32, tm_sec=37, tm_wday=3, tm_yday=221, tm_isdst=0)
In [74]:
time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(1533785557.0))
Out[74]:
‘2018-08-09 11:32:37‘
 

时间数据的操作

In [91]:
import datetime
import pandas as pd
import numpy as np
In [80]:
#取当前datetime格式的时间
datetime.datetime(2018,8,8)
Out[80]:
datetime.datetime(2018, 8, 8, 0, 0)
In [ ]:
pd.date_range()
start=None,  开始
end=None,    结束
periods=None, 生成多少个
freq=D, 默认按天计算 
tz=None, 
normalize=False, 
name=None, 
closed=None, 
**kwargs)
 

生成时间序列数据

In [81]:
#生成时间序列数据
pd.date_range(datetime.datetime(2018,8,8),periods=4)
Out[81]:
DatetimeIndex([‘2018-08-08‘, ‘2018-08-09‘, ‘2018-08-10‘, ‘2018-08-11‘], dtype=‘datetime64[ns]‘, freq=‘D‘)
In [89]:
pd.date_range("2018-8,-8",periods=4)#指定生成个数
Out[89]:
DatetimeIndex([‘2018-08-08‘, ‘2018-08-09‘, ‘2018-08-10‘, ‘2018-08-11‘], dtype=‘datetime64[ns]‘, freq=‘D‘)
In [86]:
pd.date_range("2018-8-8","2018-9-9")#指定起始日期
Out[86]:
DatetimeIndex([‘2018-08-08‘, ‘2018-08-09‘, ‘2018-08-10‘, ‘2018-08-11‘,
               ‘2018-08-12‘, ‘2018-08-13‘, ‘2018-08-14‘, ‘2018-08-15‘,
               ‘2018-08-16‘, ‘2018-08-17‘, ‘2018-08-18‘, ‘2018-08-19‘,
               ‘2018-08-20‘, ‘2018-08-21‘, ‘2018-08-22‘, ‘2018-08-23‘,
               ‘2018-08-24‘, ‘2018-08-25‘, ‘2018-08-26‘, ‘2018-08-27‘,
               ‘2018-08-28‘, ‘2018-08-29‘, ‘2018-08-30‘, ‘2018-08-31‘,
               ‘2018-09-01‘, ‘2018-09-02‘, ‘2018-09-03‘, ‘2018-09-04‘,
               ‘2018-09-05‘, ‘2018-09-06‘, ‘2018-09-07‘, ‘2018-09-08‘,
               ‘2018-09-09‘],
              dtype=‘datetime64[ns]‘, freq=‘D‘)
In [88]:
 
pd.date_range("2018-8-8 11:00","2018-8-9 00:00",freq="H")#按小时生成序列
Out[88]:
DatetimeIndex([‘2018-08-08 11:00:00‘, ‘2018-08-08 12:00:00‘,
               ‘2018-08-08 13:00:00‘, ‘2018-08-08 14:00:00‘,
               ‘2018-08-08 15:00:00‘, ‘2018-08-08 16:00:00‘,
               ‘2018-08-08 17:00:00‘, ‘2018-08-08 18:00:00‘,
               ‘2018-08-08 19:00:00‘, ‘2018-08-08 20:00:00‘,
               ‘2018-08-08 21:00:00‘, ‘2018-08-08 22:00:00‘,
               ‘2018-08-08 23:00:00‘, ‘2018-08-09 00:00:00‘],
              dtype=‘datetime64[ns]‘, freq=‘H‘)
In [93]:
ser=pd.Series(np.arange(10),index=pd.date_range("2018-8-9",periods=10))
ser
Out[93]:
2018-08-09    0
2018-08-10    1
2018-08-11    2
2018-08-12    3
2018-08-13    4
2018-08-14    5
2018-08-15    6
2018-08-16    7
2018-08-17    8
2018-08-18    9
Freq: D, dtype: int32
In [94]:
ser["2018-8-9"]
Out[94]:
0
In [96]:
ser.index[2].year
Out[96]:
2018
In [97]:
ser.index[2].month
Out[97]:
8
In [99]:
ser.index[2].day
Out[99]:
11
 

修改日期格式

pd.to_datetime()

In [123]:
df=pd.DataFrame({"日期":["2017-01-01","2017-01-02","2017-01-03","2017-02-03","2017-02-04","2017-03-01","2017-03-02"],"最高气温":
[12,13,14,15,np.nan,17,15],"最低气温":[7,8,8,np.nan,12,3,5],"天气":[np.nan,"多云","多云","小雨","小雨","",""],"风向":
["西北风",np.nan,"东北风","西北风",np.nan,"北风","南风"],"风力":[2,2,np.nan,1,2,3,2]})
In [124]:
df.info()
<class ‘pandas.core.frame.DataFrame‘>
RangeIndex: 7 entries, 0 to 6
Data columns (total 6 columns):
天气      6 non-null object
日期      7 non-null object
最低气温    6 non-null float64
最高气温    6 non-null float64
风力      6 non-null float64
风向      5 non-null object
dtypes: float64(3), object(3)
memory usage: 416.0+ bytes
 

format

In [125]:
df["日期"]=pd.to_datetime(df["日期"].values,format="%Y-%m-%d")
 
In [126]:
df.info()
<class ‘pandas.core.frame.DataFrame‘>
RangeIndex: 7 entries, 0 to 6
Data columns (total 6 columns):
天气      6 non-null object
日期      7 non-null datetime64[ns]
最低气温    6 non-null float64
最高气温    6 non-null float64
风力      6 non-null float64
风向      5 non-null object
dtypes: datetime64[ns](1), float64(3), object(2)
memory usage: 416.0+ bytes
In [109]:
df
Out[109]:
 天气日期最低气温最高气温风力风向
0 NaN 2017-01-01 7.0 12.0 2.0 西北风
1 多云 2017-01-02 8.0 13.0 2.0 NaN
2 多云 2017-01-03 8.0 14.0 NaN 东北风
3 小雨 2017-02-03 NaN 15.0 1.0 西北风
4 小雨 2017-02-04 12.0 NaN 2.0 NaN
5 2017-03-01 3.0 17.0 3.0 北风
6 2017-03-02 5.0 15.0 2.0 南风
In [130]:
#将日期设置为索引
df=df.set_index("日期")
In [131]:
df
 Out[131]:
 天气最低气温最高气温风力风向
日期     
2017-01-01 NaN 7.0 12.0 2.0 西北风
2017-01-02 多云 8.0 13.0 2.0 NaN
2017-01-03 多云 8.0 14.0 NaN 东北风
2017-02-03 小雨 NaN 15.0 1.0 西北风
2017-02-04 小雨 12.0 NaN 2.0 NaN
2017-03-01 3.0 17.0 3.0 北风
2017-03-02 5.0 15.0 2.0 南风
In [117]:
 #提取1月份的数据
df_join=df[(df.index>="2017-01-01")&(df.index<="2017-02-01")]#注意时间输入需与索引格式一致
df_join

 

Out[117]:
 天气最低气温最高气温风力风向
日期     
2017-01-01 NaN 7.0 12.0 2.0 西北风
2017-01-02 多云 8.0 13.0 2.0 NaN
2017-01-03 多云 8.0 14.0 NaN 东北风
In [119]:
 df["2017-01-01":"2017-01-31"].info()
<class ‘pandas.core.frame.DataFrame‘>
Index: 3 entries, 2017-01-01 to 2017-01-03
Data columns (total 5 columns):
天气      2 non-null object
最低气温    3 non-null float64
最高气温    3 non-null float64
风力      2 non-null float64
风向      2 non-null object
dtypes: float64(3), object(2)
memory usage: 144.0+ bytes
In [132]:
#转换成月份
df.to_period("M")
Out[132]:
 天气最低气温最高气温风力风向
日期     
2017-01 NaN 7.0 12.0 2.0 西北风
2017-01 多云 8.0 13.0 2.0 NaN
2017-01 多云 8.0 14.0 NaN 东北风
2017-02 小雨 NaN 15.0 1.0 西北风
2017-02 小雨 12.0 NaN 2.0 NaN
2017-03 3.0 17.0 3.0 北风
2017-03 5.0 15.0 2.0 南风
 

处理字符型数据

In [155]:
data=pd.DataFrame({"Rank":[1,2,3,4,5],"city":["london","benrlin]","madind","rome","pans"],"state":[" kingdom"," gemany","spain ","ltaly","frnce"],
"popuiation":["8,615,246","3,437,916","3,165,235","2,872,086","2,273,305"],"dateofcensusestumate":["1 june 2014","31 may 2014",
"1 january 2014","30 september 2014","1 jannany 2013"]})
In [156]:
data
Out[156]:
 Rankcitydateofcensusestumatepopuiationstate
0 1 london 1 june 2014 8,615,246 kingdom
1 2 benrlin] 31 may 2014 3,437,916 gemany
2 3 madind 1 january 2014 3,165,235 spain
3 4 rome 30 september 2014 2,872,086 ltaly
4 5 pans 1 jannany 2013 2,273,305 frnce
In [157]:
date=data.reindex(["Rank"]+["city"]+["state"]+["popuiation"]+["dateofcensusestumate"],axis=1)#排序
In [158]:
date
Out[158]:
 Rankcitystatepopuiationdateofcensusestumate
0 1 london kingdom 8,615,246 1 june 2014
1 2 benrlin] gemany 3,437,916 31 may 2014
2 3 madind spain 3,165,235 1 january 2014
3 4 rome ltaly 2,872,086 30 september 2014
4 5 pans frnce 2,273,305 1 jannany 2013
In [159]:
date.info()
<class ‘pandas.core.frame.DataFrame‘>
RangeIndex: 5 entries, 0 to 4
Data columns (total 5 columns):
Rank                    5 non-null int64
city                    5 non-null object
state                   5 non-null object
popuiation              5 non-null object
dateofcensusestumate    5 non-null object
dtypes: int64(1), object(4)
memory usage: 280.0+ bytes
 

去掉逗号

 

split()分割函数

In [160]:
date["popuiation"].apply(lambda x :x.split(","))#按照逗号分隔
Out[160]:
0    [8, 615, 246]
1    [3, 437, 916]
2    [3, 165, 235]
3    [2, 872, 086]
4    [2, 273, 305]
Name: popuiation, dtype: object
In [161]:
date["popuiation"].apply(lambda x :x.replace(",",""))#把逗号替代为空
#lambda 匿名函数
#apply 循环
Out[161]:
0    8615246
1    3437916
2    3165235
3    2872086
4    2273305
Name: popuiation, dtype: object
 

replace()替换函数

In [162]:
subtr=date["popuiation"].apply(lambda x : int(x.replace(",","")))
In [163]:
date["numericpopuiation"]=subtr
date
Out[163]:
 Rankcitystatepopuiationdateofcensusestumatenumericpopuiation
0 1 london kingdom 8,615,246 1 june 2014 8615246
1 2 benrlin] gemany 3,437,916 31 may 2014 3437916
2 3 madind spain 3,165,235 1 january 2014 3165235
3 4 rome ltaly 2,872,086 30 september 2014 2872086
4 5 pans frnce 2,273,305 1 jannany 2013 2273305
In [165]:
date["state"].values# 发现数据有空格
Out[165]:
array([‘ kingdom‘, ‘ gemany‘, ‘spain ‘, ‘ltaly‘, ‘frnce‘], dtype=object)
 

strip()剔除前后空格函数

In [167]:
date["state"].apply(lambda x :x.strip())#剔除前后空格
Out[167]:
0    kingdom
1     gemany
2      spain
3      ltaly
4      frnce
Name: state, dtype: object
In [170]:
stri=date["state"].apply(lambda x :x.strip())#空格没有了
date["stace"]=stri
date["stace"].values
Out[170]:
array([‘kingdom‘, ‘gemany‘, ‘spain‘, ‘ltaly‘, ‘frnce‘], dtype=object)
 

对指定字符串进行处理

 

如果我们需要在一系列文本中提取数据?

 

正则表达式通常被用来检索某个规则的文本

In [172]:
str_1=pd.DataFrame({"title":["网名最喜欢的旅游目的地榜单出炉","让生活更幸福是旅游业的使命","一带一路国家中东欧游客增两倍","旅游业改革开启旅游强国新篇章"],
"link":["http//cntour.cninews/4221/","http//cntour.cninews/4212/","http//cntour.cninews/4202/","http//cntour.cninews/4191/"]})
In [173]:
str_1
Out[173]:
 linktitle
0 http//cntour.cninews/4221/ 网名最喜欢的旅游目的地榜单出炉
1 http//cntour.cninews/4212/ 让生活更幸福是旅游业的使命
2 http//cntour.cninews/4202/ 一带一路国家中东欧游客增两倍
3 http//cntour.cninews/4191/ 旅游业改革开启旅游强国新篇章
 

str.extract()运用正则表达式(表达式详情百度查看)

注:括号里面是需要的内容

In [175]:
str_1["link"]
Out[175]:
0    http//cntour.cninews/4221/
1    http//cntour.cninews/4212/
2    http//cntour.cninews/4202/
3    http//cntour.cninews/4191/
Name: link, dtype: object
In [178]:
str_1["link"].str.extract("ews/(.+)/",expand=False)
Out[178]:
0    4221
1    4212
2    4202
3    4191
Name: link, dtype: object
In [181]:
str_2=str_1["link"].str.extract("ews/(.+)/",expand=False)
str_1["links"]=str_2
str_1
Out[181]:
 linktitlelinks
0 http//cntour.cninews/4221/ 网名最喜欢的旅游目的地榜单出炉 4221
1 http//cntour.cninews/4212/ 让生活更幸福是旅游业的使命 4212
2 http//cntour.cninews/4202/ 一带一路国家中东欧游客增两倍 4202
3 http//cntour.cninews/4191/ 旅游业改革开启旅游强国新篇章 4191
In [188]:
 dic={"4221":"","4212":"","4202":"","4191":""}
In [191]:
%%time
str_1["linkss"]=str_1["links"].map(dic)#map 映射函数,可将dic的值 根据键一一对应,映射到str——1
str_1
Wall time: 3 ms
 linktitlelinkslinkss
0 http//cntour.cninews/4221/ 网名最喜欢的旅游目的地榜单出炉 4221
1 http//cntour.cninews/4212/ 让生活更幸福是旅游业的使命 4212
2 http//cntour.cninews/4202/ 一带一路国家中东欧游客增两倍 4202
3 http//cntour.cninews/4191/ 旅游业改革开启旅游强国新篇章 4191
 
 

利用python 进行数据清洗

标签:evel   输入   copy   ica   pandas   war   重复   格式化   种子   

原文地址:https://www.cnblogs.com/Koi504330/p/11902191.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!