利用python 进行数据清洗

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()

in [6]:

#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]:

  first weight_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]:

  first weight_column
2 6 0.2
1 5 0.4

In [29]:

 df.sample(n=2,axis=1)

Out[29]:

  weight_column first
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]:

  first weight_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]:

  A B C D
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]:

  B C E
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]:

  A B C D B C E
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]:

  A B C D B C E
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]:

  A B C D B C E
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]:

  A B C D E
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]:

  A B C D E
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]:

  A B C D s
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]:

    A B C D
one 0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
two 4 A0 B0 C0 D0
5 A1 B1 C1 D1
6 A2 B2 C2 D2
7 A3 B3 C3 D3
three 8 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]:

    A B C D
one 0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
three 8 A0 B0 C0 D0
9 A1 B1 C1 D1
10 A2 B2 C2 D2
11 A3 B3 C3 D3
two 4 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]:

  A B C D E
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]:

  A B C D
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]:

  A B C D
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  Locale‘s abbreviated weekday name.
%A  Locale‘s full weekday name.
%b  Locale‘s abbreviated month name.
%B  Locale‘s full month name.
%c  Locale‘s appropriate date and time representation.
%I  Hour (12-hour clock) as a decimal number [01,12].
%p  Locale‘s 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]:

  Rank city dateofcensusestumate popuiation state
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]:

  Rank city state popuiation dateofcensusestumate
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]:

  Rank city state popuiation dateofcensusestumate numericpopuiation
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]:

  link title
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]:

  link title links
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
  link title links linkss
0 http//cntour.cninews/4221/ 网名最喜欢的旅游目的地榜单出炉 4221 过
1 http//cntour.cninews/4212/ 让生活更幸福是旅游业的使命 4212 来
2 http//cntour.cninews/4202/ 一带一路国家中东欧游客增两倍 4202 玩
3 http//cntour.cninews/4191/ 旅游业改革开启旅游强国新篇章 4191 啊 
 

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

时间： 2024-08-30 06:28:44

利用python 进行数据清洗的相关文章

利用python进行数据分析－－（阅读笔记一）

以此记录阅读和学习<利用Python进行数据分析>这本书中的觉得重要的点! 第一章:准备工作 1.一组新闻文章可以被处理为一张词频表,这张词频表可以用于情感分析. 2.大多数软件是由两部分代码组成:少量需要占用大部分执行时间的代码,以及大量不经常执行的“粘合剂代码”. cython已经成为python领域中创建编译型扩展以及对接c/c++代码的一大途径. 3.在那些要求延迟性非常小的应用程序中(例如高频交易系统),为了尽最大可能地优化性能,耗费时间使用诸如C++这样更低级.更低生产率的语言进行

利用 Python yield 创建协程将异步编程同步化

在 Lua 和 Python 等脚本语言中,经常提到一个概念: 协程.也经常会有同学对协程的概念及其作用比较疑惑,本文今天就来探讨下协程的前世今生. 首先回答一个大家最关心的问题:协程的好处是什么? 通俗易懂的回答: 让原来要使用 异步 + 回调 方式写的非人类代码,可以用看似同步的方式写出来. 1.回顾同步与异步编程 同步编程即线性化编程,代码按照既定顺序执行,上一条语句执行完才会执行下一条,否则就一直等在那里. 但是许多实际操作都是CPU 密集型任务和 IO 密集型任务,比如网络请求,此时不

利用Python实现归并排序

利用python进行归并排序,摘抄自http://blog.csdn.net/minxihou/article/details/51821052 "代码真的不是一气呵成的,而且也不是想当然写出来的.可能需要反复断点中断来查看是否有逻辑错误.在理解了问题的基础下我们需要先把大体的代码框架最好先写出来,特别是主要的逻辑判断语句.但是不需要太care我循环体或者判断里面语句怎么实现,当你把这一步做到的时候能避免很多不必要的错误发生." 1 import random 2 3 def Conf

利用Python脚本管理Windows服务

Windows服务常用的功能就是启动服务,关闭服务,重启服务和查询服务运行状态,其中查询服务运行状态是其他三种操作的基础. 本文中提到的使用Python脚本管理Windows服务实际上是调用win32serviceutil模块,此模块来自pywin32包,此模块本身有管理服务的功能,有兴趣的可以去阅读它的部分源码. 本脚本存在的目的是为了熟练Python的语法和基本操作,Windows下有更好的命令行工具来管理服务,如sc.Powershell等.通常命令行工具的执行速度要比services.m

《利用python进行数据分析》

今天开始码这本书--<利用python进行数据分析>.R和python都得会用才行,这是码这本书的原因.首先按照书上说的进行安装,google下载了epd_free-7.3-1-win-x86.msi,译者建议按照作者的版本安装.

利用Python编写网络爬虫下载文章

#coding: utf-8 #title..href... str0='blabla<a title="<论电影的七个元素>——关于我对电影的一些看法以及<后会无期>的一些消息" target="_blank" href="http://blog.sina.com.cn/s/blog_4701280b0102eo83.html"><论电影的七个元素>——关于我对电…</a>' impo

利用python实现二分法

利用python实现二分法:我的实现思路如下 1.判断要查找的值是否大于最大值,如果大于则直接返回False 2.判断要查找的值是否小于最小值,如果小于则直接返回False 3.如果要查找的值在最大值和最小值之间,则进入循环 a.首先序列的长度要大于1,然后获取序列中间一个值的大小 b.然后和要查找的值做比较,如果相等,则直接返回True,如果不相等,则判断如果中间的值大于要查找的值,则说明要查找的值在该中间值的左边,如果中间的值小于要查找的值,则说明要查找的值在中间的值的右边 c.最后如果序列

利用python进行数据分析——（一）库的学习

总结一下自己对python常用包:Numpy,Pandas,Matplotlib,Scipy,Scikit-learn 一. Numpy: 标准安装的Python中用列表(list)保存一组值,可以用来当作数组使用,不过由于列表的元素可以是任何对象,因此列表中所保存的是对象的指 针.这样为了保存一个简单的[1,2,3],需要有3个指针和三个整数对象.对于数值运算来说这种结构显然比较浪费内存和CPU计算时间. 此外Python还提供了一个array模块,array对象和列表不同,它直接保存数值,和

Windows下利用Python动态检测外网IP并发邮件给邮箱

我们知道,运营商给分配的都是动态IP,IP地址过一段时间会自己变化,这就给需要静态地址的应用带来不便,例如搭建服务器或者远程控制电脑,这种情况必须知道自己电脑的IP,利用Python可以方便的自动检测并向邮箱发送邮箱. 但是,个人网络一般都是通过路由器来上网,直接检测电脑的IP并不可行,需要得到外网的IP.内网电脑可以通过端口映射来映射到外网.检测的原理如下: 1.通过自己的电脑信息不太好获取外网IP,幸好有一些雷锋网站可以帮助我们来检测,例如 http://city.ip138.com/ip2