pandas 学习笔记【持续更新】

其他 2019-10-05 22:01:16 阅读次数: 0 
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
df1 = pd.DataFrame(np.arange(1000, 1100, 4).reshape(5,5), index=['a'+str(i) for i in range(5)], columns=['b'+str(j) for j in range(5)])
df1
b0 b1 b2 b3 b4
a0 1000 1004 1008 1012 1016
a1 1020 1024 1028 1032 1036
a2 1040 1044 1048 1052 1056
a3 1060 1064 1068 1072 1076
a4 1080 1084 1088 1092 1096 
df2 = pd.Series([1, 2, 3, np.nan, 5], index=list('abcde'))
df2
a    1.0
b    2.0
c    3.0
d    NaN
e    5.0
dtype: float64

使用传递的numpy数组创建数据帧,并使用日期索引和标记列.

dates = pd.date_range('20190524',periods=6)
dates
print('-'*30)
df3 = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
df3
------------------------------
A B C D
2019-05-24 -0.860206 -0.549105 -1.357905 -0.847048
2019-05-25 1.913799 -0.655915 -0.638752 -0.459323
2019-05-26 0.249178 -1.658453 -2.278093 -0.745429
2019-05-27 0.452118 0.527087 -0.298735 -1.872822
2019-05-28 -1.472450 0.124642 1.554257 -0.085878
2019-05-29 -2.175467 -0.611948 -0.062950 -0.709390

使用传递的可转换序列的字典对象创建数据帧.

df4 = pd.DataFrame({
        'id' : np.arange(4),
        'date' : pd.Timestamp('20190524'),
        'type' : pd.Series(1,index=list(range(4)),dtype='float32'),
        'D' : np.array([3] * 4,dtype='int32'),
        'E' : pd.Categorical(["test","train","test","train"]),
        'F' : 'foo'
    })
df4
id date type D E F
0 0 2019-05-24 1.0 3 test foo
1 1 2019-05-24 1.0 3 train foo
2 2 2019-05-24 1.0 3 test foo
3 3 2019-05-24 1.0 3 train foo

单看index， columns， values

df4.index, df4.columns
(Int64Index([0, 1, 2, 3], dtype='int64'),
 Index(['id', 'date', 'type', 'D', 'E', 'F'], dtype='object'))
df3.values
array([[-0.86020569, -0.5491055 , -1.3579045 , -0.84704786],
       [ 1.91379872, -0.65591487, -0.63875153, -0.4593228 ],
       [ 0.24917803, -1.65845292, -2.27809285, -0.74542856],
       [ 0.45211825,  0.52708701, -0.29873468, -1.87282174],
       [-1.47245001,  0.12464238,  1.55425716, -0.08587762],
       [-2.17546674, -0.61194779, -0.06294959, -0.70938972]])

显示数据快速统计摘要

df3.describe()
A B C D
count 6.000000 6.000000 6.000000 6.000000
mean -0.315505 -0.470615 -0.513696 -0.786648
std 1.481390 0.751155 1.293618 0.598216
min -2.175467 -1.658453 -2.278093 -1.872822
25% -1.319389 -0.644923 -1.178116 -0.821643
50% -0.305514 -0.580527 -0.468743 -0.727409
75% 0.401383 -0.043795 -0.121896 -0.521840
max 1.913799 0.527087 1.554257 -0.085878 
df4.describe()
id type D
count 4.000000 4.0 4.0
mean 1.500000 1.0 3.0
std 1.290994 0.0 0.0
min 0.000000 1.0 3.0
25% 0.750000 1.0 3.0
50% 1.500000 1.0 3.0
75% 2.250000 1.0 3.0
max 3.000000 1.0 3.0

转置

df4.T
0 1 2 3
id 0 1 2 3
date 2019-05-24 00:00:00 2019-05-24 00:00:00 2019-05-24 00:00:00 2019-05-24 00:00:00
type 1 1 1 1
D 3 3 3 3
E test train test train
F foo foo foo foo

按值排序

df3.sort_values(by='B')
A B C D
2019-05-26 0.249178 -1.658453 -2.278093 -0.745429
2019-05-25 1.913799 -0.655915 -0.638752 -0.459323
2019-05-29 -2.175467 -0.611948 -0.062950 -0.709390
2019-05-24 -0.860206 -0.549105 -1.357905 -0.847048
2019-05-28 -1.472450 0.124642 1.554257 -0.085878
2019-05-27 0.452118 0.527087 -0.298735 -1.872822

按轴排序

df3.sort_index(axis=1, ascending=False)
D C B A
2019-05-24 -0.847048 -1.357905 -0.549105 -0.860206
2019-05-25 -0.459323 -0.638752 -0.655915 1.913799
2019-05-26 -0.745429 -2.278093 -1.658453 0.249178
2019-05-27 -1.872822 -0.298735 0.527087 0.452118
2019-05-28 -0.085878 1.554257 0.124642 -1.472450
2019-05-29 -0.709390 -0.062950 -0.611948 -2.175467

选择-按标签选择 df.loc[]

# 切片 索引
print(df3['A'])
print('-'*30)
print(df4['E'])
print('-'*30)
print(df3[1:3])
print('-'*30)
print(df3['20190524':'20190525'])
2019-05-24   -0.860206
2019-05-25    1.913799
2019-05-26    0.249178
2019-05-27    0.452118
2019-05-28   -1.472450
2019-05-29   -2.175467
Freq: D, Name: A, dtype: float64
------------------------------
0     test
1    train
2     test
3    train
Name: E, dtype: category
Categories (2, object): [test, train]
------------------------------
                   A         B         C         D
2019-05-25  1.913799 -0.655915 -0.638752 -0.459323
2019-05-26  0.249178 -1.658453 -2.278093 -0.745429
------------------------------
                   A         B         C         D
2019-05-24 -0.860206 -0.549105 -1.357905 -0.847048
2019-05-25  1.913799 -0.655915 -0.638752 -0.459323
# 使用标签获取横截面，参考以下示例
dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.arange(1, 25).reshape(6,4), index=dates, columns=list('ABCD'))
df
A B C D
2013-01-01 1 2 3 4
2013-01-02 5 6 7 8
2013-01-03 9 10 11 12
2013-01-04 13 14 15 16
2013-01-05 17 18 19 20
2013-01-06 21 22 23 24 
# 使用标签获取横截面
print(df.loc[dates[0]])
A    1
B    2
C    3
D    4
Name: 2013-01-01 00:00:00, dtype: int32
# 索引切片-选择指定若干列
df.loc[:,['A','B']]
A B
2013-01-01 1 2
2013-01-02 5 6
2013-01-03 9 10
2013-01-04 13 14
2013-01-05 17 18
2013-01-06 21 22 
# 选取区域-行列同时切片索引
df.loc['20130102':'20130104', ['A', 'B']]
A B
2013-01-02 5 6
2013-01-03 9 10
2013-01-04 13 14 
# 由于切片索引自动降维
df.loc['20130102', ['A', 'B']]
A    5
B    6
Name: 2013-01-02 00:00:00, dtype: int32
# 取单个标量值-两种结果完全一样的方法loc位置， at位于
print(df.loc[dates[4], 'C'])
print(df.at[dates[4],'C'])
19
19

选择-按位置选择 df.iloc[]

# 选第三行。第三条。第三条记录
df.iloc[3]
A    13
B    14
C    15
D    16
Name: 2013-01-04 00:00:00, dtype: int32
# 选取3到5行，1到3列的区域形成新DataFrame
df.iloc[3:5, 1:3]
B C
2013-01-04 14 15
2013-01-05 18 19 
# 使用整数偏移定位列表，隔行选择， 可以多选，可以自定义重复
df.iloc[[1,2,2,4],[0,2]]
A C
2013-01-02 5 7
2013-01-03 9 11
2013-01-03 9 11
2013-01-05 17 19 
# 灵活使用列表生成条件表达式-疯狂复读重复某一行限定区块
df.iloc[[3 for i in range(5)],[0,2]]
A C
2013-01-04 13 15
2013-01-04 13 15
2013-01-04 13 15
2013-01-04 13 15
2013-01-04 13 15

------------------------学习蚂蚁 pandas----------------------

快速开始-基本使用

import pandas as pd
fpath = './datas/ml-latest-small/ratings.csv'
# 使用 pd.read_csv 读取 csv 数据
ratings = pd.read_csv(fpath)
# 使用 df.head() 查看 dataframe 的前几行
ratings.head()
userId movieId rating timestamp
0 1 1 4.0 964982703
1 1 3 4.0 964981247
2 1 6 4.0 964982224
3 1 47 5.0 964983815
4 1 50 5.0 964982931 
# 使用 df.shape() 查看数据表的形状
ratings.shape # 看起来好像挺大的样子
(100836, 4)
# 列名列表
ratings.columns
Index(['userId', 'movieId', 'rating', 'timestamp'], dtype='object')
# 索引列表
ratings.index # 0-100836 步长1
RangeIndex(start=0, stop=100836, step=1)
# 每一列的数据类型
ratings.dtypes
userId         int64
movieId        int64
rating       float64
timestamp      int64
dtype: object

1、读取 txt 文件

path1 = './datas/crazyant/access_pvuv.txt'
df1 = pd.read_csv(
    path1, # 源文件路径
    sep='\t', # 以制表符为分隔符分割源文件
    header=None, # 没有字段行，所以要设置 names 
    names=['pdata', 'pv', 'uv'] # 自定义列名列表
)
df1
pdata pv uv
0 2019-09-10 139 92
1 2019-09-09 185 153
2 2019-09-08 123 59
3 2019-09-07 65 40
4 2019-09-06 157 98
5 2019-09-05 205 151
6 2019-09-04 196 167
7 2019-09-03 216 176
8 2019-09-02 227 148
9 2019-09-01 105 61

读取 excel 文件

path2 = './datas/crazyant/access_pvuv.xlsx'
df2 = pd.read_excel(path2)
df2
日期 PV UV
0 2019-09-10 139 92
1 2019-09-09 185 153
2 2019-09-08 123 59
3 2019-09-07 65 40
4 2019-09-06 157 98
5 2019-09-05 205 151
6 2019-09-04 196 167
7 2019-09-03 216 176
8 2019-09-02 227 148
9 2019-09-01 105 61

读取 sql 数据库数据

import pymysql
# pandas 从数据库读取数据表需要有 mysql 连接
conn = pymysql.connect(
    host='127.0.0.1',
    user='root',
    password='root',
    database='stock',
    charset='utf8'
)
# 从 数据库连接中通过执行原生sql读取数据表
df_sql = pd.read_sql('select * from k_goods', conn)
df_sql
ID PRODUCTNO PRODUCTNAME PRODUCTTYPE PRODUCTSTANDARD UNIT PRICE REMARK
0 1 pdno_0001 计算器 桌面文具 00 个 20 None
1 2 pdno_0002 回形针 桌面文具 00 个 5 None
2 3 pdno_0003 中性笔 桌面文具 00 支 5 None
3 4 pdno_0004 复印纸 纸制品 00 盒 10 None
4 5 pdno_0005 账本 纸制品 00 本 2 None
5 6 pdno_0006 拖布 办公生活用品 00 个 20 None
6 7 pdno_0007 小蜜蜂扩音器 授课设备 00 个 25 None
7 8 pdno_0008 纸杯 办公生活用品 00 个 5 None
8 9 pdno_0009 白板 桌面文具 00 块 50 None
9 10 pdno_0010 软面炒 纸制品 00 本 1 None
10 11 pdno_0011 双面胶 桌面文具 00 个 2 None
11 12 pdno_0012 文件夹 桌面文具 00 把 3 None
12 13 pdno_0013 剪刀 文件管理用品 00 个 8 None
13 14 pdno_0014 档案盒 文件管理用品 00 个 10 None
14 15 pdno_0015 电脑 办公集写 00 个 2000 None

pandas 数据集结构

  1. Series
  2. DataFrame
  3. 从DataFrame中查询出Series

Series 序列/一维/字典

给定values列表创建Series，默认 index 是range序列

s1 = pd.Series([1,'a',5.2,7])
s1 # 类似字典
0      1
1      a
2    5.2
3      7
dtype: object
# 索引列表 dict.keys()
s1.index
RangeIndex(start=0, stop=4, step=1)
# 值列表 dict.values()
s1.values
array([1, 'a', 5.2, 7], dtype=object)

给定 values列表和index列表创建Series

### 给定 key 和 vlu
s21 = pd.Series(range(5), index=['a','b','c','d','e'])
s22 = pd.Series([x - 2 for x in range(5, 14, 2)], index=['a','b','c','d','e'])
s23 = pd.Series([1, 'a', 5.2, 7, 0.14], ['a','b','c','d','e'])
print(s21)
print(s22)
print(s23)
a    0
b    1
c    2
d    3
e    4
dtype: int64
a     3
b     5
c     7
d     9
e    11
dtype: int64
a       1
b       a
c     5.2
d       7
e    0.14
dtype: object

使用字典创建 Series

sdata={
    'Ohio':35000,
    'Texas':72000,
    'Oregon':16000,
    'Utah':5000
}
s3=pd.Series(sdata)
s3
Ohio      35000
Texas     72000
Oregon    16000
Utah       5000
dtype: int64

根据索引查询数据

print(s3['Ohio'], '\n')
# 给定指定索引列表来索引
print(s3[['Ohio', 'Texas']], '\n') # 只要不是一个都仍是个Series
# 切片索引
print(s3['Ohio':'Utah']) 
35000 

Ohio     35000
Texas    72000
dtype: int64 

Ohio      35000
Texas     72000
Oregon    16000
Utah       5000
dtype: int64

DataFrame 表格/二维/数据表

2. DataFrame

DataFrame是一个表格型的数据结构

  • 每列可以是不同的值类型（数值、字符串、布尔值等）
  • 既有行索引index,也有列索引columns
  • 可以被看做由Series组成的字典

创建dataframe最常用的方法，见02节读取纯文本文件、excel、mysql数据库

根据嵌套的字典创建DataFrame 类似与golang 的 map[string][]interface{}

data={
        'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],
        'year':[2000,2001,2002,2001,2002],
        'pop':[1.5,1.7,3.6,2.4,2.9]
    }
df3 = pd.DataFrame(data)
df3
state year pop
0 Ohio 2000 1.5
1 Ohio 2001 1.7
2 Ohio 2002 3.6
3 Nevada 2001 2.4
4 Nevada 2002 2.9 
# 列名列表
df3.columns
Index(['state', 'year', 'pop'], dtype='object')
# 索引列表
df3.index
RangeIndex(start=0, stop=5, step=1)
# 形状/维度
df3.shape
(5, 3)
# 每一列的数据类型
df3.dtypes
state     object
year       int64
pop      float64
dtype: object
# 值
df3.values
array([['Ohio', 2000, 1.5],
       ['Ohio', 2001, 1.7],
       ['Ohio', 2002, 3.6],
       ['Nevada', 2001, 2.4],
       ['Nevada', 2002, 2.9]], dtype=object)

从DataFrame中查询出Series

  • 如果只查询一行、一列，返回的是pd.Series
  • 如果查询多行、多列，返回的是pd.DataFrame
# 索引一列 返回一个Series
df3['year']
0    2000
1    2001
2    2002
3    2001
4    2002
Name: year, dtype: int64
# 索引多列 返回一个DataFrame
df3[['year', 'pop']]
year pop
0 2000 1.5
1 2001 1.7
2 2002 3.6
3 2001 2.4
4 2002 2.9 
# 查询一列 返回Series
df3.loc[1]
state    Ohio
year     2001
pop       1.7
Name: 1, dtype: object
# 查询指定多列 返回DataFrame
df3.loc[[1:3]]
# 查询范围多列 返回DataFrame
df3.loc[[1, 3]]
state year pop
1 Ohio 2001 1.7
3 Nevada 2001 2.4

pandas 数据查询

Pandas查询数据的几种方法

  1. df.loc方法，根据行、列的标签值查询
  2. df.iloc方法，根据行、列的数字位置查询
  3. df.where方法
  4. df.query方法

.loc既能查询，又能覆盖写入，强烈推荐！

Pandas使用df.loc查询数据的方法

  1. 使用单个label值查询数据
  2. 使用值列表批量查询
  3. 使用数值区间进行范围查询
  4. 使用条件表达式查询
  5. 调用函数查询

注意

  • 以上查询方法，既适用于行，也适用于列
  • 注意观察降维dataFrame>Series>值

0、读取数据

数据为北京2018年全年天气预报
该数据的爬虫教程参见我的Python爬虫系列视频课程

dff = pd.read_csv('./datas/beijing_tianqi/beijing_tianqi_2018.csv')
dff.head()
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
0 2018-01-01 3℃ -6℃ 晴~多云 东北风 1-2级 59 良 2
1 2018-01-02 2℃ -5℃ 阴~多云 东北风 1-2级 49 优 1
2 2018-01-03 2℃ -5℃ 多云 北风 1-2级 28 优 1
3 2018-01-04 0℃ -8℃ 阴 东北风 1-2级 28 优 1
4 2018-01-05 3℃ -6℃ 多云~晴 西北风 1-2级 50 优 1 
# 设定指定列为列【日期】，方便按日期筛选
dff.set_index('ymd', inplace=True)
# 按字符串处理
dff.head()
bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
ymd
2018-01-01 3℃ -6℃ 晴~多云 东北风 1-2级 59 良 2
2018-01-02 2℃ -5℃ 阴~多云 东北风 1-2级 49 优 1
2018-01-03 2℃ -5℃ 多云 北风 1-2级 28 优 1
2018-01-04 0℃ -8℃ 阴 东北风 1-2级 28 优 1
2018-01-05 3℃ -6℃ 多云~晴 西北风 1-2级 50 优 1 
# 替换掉温度的后缀℃
dff.loc[:, "bWendu"] = dff["bWendu"].str.replace("℃", "").astype('int32')
dff.loc[:, "yWendu"] = dff["yWendu"].str.replace("℃", "").astype('int32')
# 再查看，温度列已经转换成了防便计算的数据类型
dff.head()
bWendu        int32
yWendu        int32
tianqi       object
fengxiang    object
fengli       object
aqi           int64
aqiInfo      object
aqiLevel      int64
dtype: object
dff.head()
bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
ymd
2018-01-01 3 -6 晴~多云 东北风 1-2级 59 良 2
2018-01-02 2 -5 阴~多云 东北风 1-2级 49 优 1
2018-01-03 2 -5 多云 北风 1-2级 28 优 1
2018-01-04 0 -8 阴 东北风 1-2级 28 优 1
2018-01-05 3 -6 多云~晴 西北风 1-2级 50 优 1

1、使用单个label值查询数据

行或者列，都可以只传入单个值，实现精确匹配

# 查询指定行的指定列 得到单个数据
dff.loc['2018-01-03', 'bWendu']
2
# 查询指定行的部分列 得到一个Series
dff.loc['2018-01-03', ['bWendu', 'yWendu']]
bWendu     2
yWendu    -5
Name: 2018-01-03, dtype: object

2、使用值列表批量查询

# 查询部分指定行的指定列 得到Series
df.loc[['2018-01-03','2018-01-04','2018-01-05'], 'bWendu']
bWendu     2
yWendu    -5
Name: 2018-01-03, dtype: object
# 查询区块 得到一个DataFrame
dff.loc[['2018-01-03','2018-01-04','2018-01-05'], ['bWendu', 'yWendu']]
bWendu yWendu
ymd
2018-01-03 2 -5
2018-01-04 0 -8
2018-01-05 3 -6

3、使用数值区间进行范围查询

注意：区间既包含开始，也包含结束

# 查询行区间的指定列 得到Series
dff.loc['2018-01-03':'2018-01-05', 'bWendu']
ymd
2018-01-03    2
2018-01-04    0
2018-01-05    3
Name: bWendu, dtype: int32
# 查寻指定行的列区间 得到Series
dff.loc['2018-01-03', 'bWendu':'fengxiang']
bWendu        2
yWendu       -5
tianqi       多云
fengxiang    北风
Name: 2018-01-03, dtype: object
# 行和列都按区间查询 得到DaTaFrame
dff.loc['2018-01-03':'2018-01-05', 'bWendu':'fengxiang']
bWendu yWendu tianqi fengxiang
ymd
2018-01-03 2 -5 多云 北风
2018-01-04 0 -8 阴 东北风
2018-01-05 3 -6 多云~晴 西北风

4、使用条件表达式查询

bool列表的长度得等于行数或者列数

# 观察一下boolean条件 返回布尔对应关系表
bool_map = (dff["yWendu"]<-10)
bool_map.head() # 【单一条件查询，最低温度低于-10度的列表】
ymd
2018-01-01    False
2018-01-02    False
2018-01-03    False
2018-01-04    False
2018-01-05    False
Name: yWendu, dtype: bool
# 根据布尔关系对应表 查询10°C一下的天
dff.loc[bool_map, :]
bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
ymd
2018-01-23 -4 -12 晴 西北风 3-4级 31 优 1
2018-01-24 -4 -11 晴 西南风 1-2级 34 优 1
2018-01-25 -3 -11 多云 东北风 1-2级 27 优 1
2018-12-26 -2 -11 晴~多云 东北风 2级 26 优 1
2018-12-27 -5 -12 多云~晴 西北风 3级 48 优 1
2018-12-28 -3 -11 晴 西北风 3级 40 优 1
2018-12-29 -3 -12 晴 西北风 2级 29 优 1
2018-12-30 -2 -11 晴~多云 东北风 1级 31 优 1 
# 观察一下boolean条件 返回布尔对应关系表 【多个布尔对应关系表结合成目标布尔关系对应表】
# 【查询最高温度小于30度，并且最低温度大于15度，并且是晴天，并且天气为优的数据】
bool_map1 = (dff["bWendu"]<=30) & (dff["yWendu"]>=15) & (dff["tianqi"]=='晴') & (dff["aqiLevel"]==1)
bool_map1.head()
ymd
2018-01-01    False
2018-01-02    False
2018-01-03    False
2018-01-04    False
2018-01-05    False
dtype: bool
# 根据布尔关系对应表 查询10°C一下的天查询最高温度小于30度，并且最低温度大于15度，并且是晴天，并且天气为优的数据
dff.loc[bool_map1, :] # 看起来只有两天
bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
ymd
2018-08-24 30 20 晴 北风 1-2级 40 优 1
2018-09-07 27 16 晴 西北风 3-4级 22 优 1

5、调用函数查询

# 直接写lambda表达式
dff.loc[lambda dff : (dff["bWendu"]<=30) & (dff["yWendu"]>=15), :]
# 编写自己的函数，查询9月份，空气质量好的数据
def query_my_data(dff):
    return dff.index.str.startswith("2018-09") & df["aqiLevel"]==1
    
dff.loc[query_my_data, :]

pandas 新增数据列

  1. 直接赋值
  2. df.apply
  3. df.assign
  4. 按条件选择分组分别赋值

0、读取csv数据

dfm = pd.read_csv('./datas/beijing_tianqi/beijing_tianqi_2018.csv')
dfm.head()
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
0 2018-01-01 3℃ -6℃ 晴~多云 东北风 1-2级 59 良 2
1 2018-01-02 2℃ -5℃ 阴~多云 东北风 1-2级 49 优 1
2 2018-01-03 2℃ -5℃ 多云 北风 1-2级 28 优 1
3 2018-01-04 0℃ -8℃ 阴 东北风 1-2级 28 优 1
4 2018-01-05 3℃ -6℃ 多云~晴 西北风 1-2级 50 优 1

1、直接赋值的方法

清理温度列变成数字类型

# 替换掉温度的后缀℃
dfm.loc[:, "bWendu"] = dfm["bWendu"].str.replace("℃", "").astype('int32')
dfm.loc[:, "yWendu"] = dfm["yWendu"].str.replace("℃", "").astype('int32')
dfm.head()
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
0 2018-01-01 3 -6 晴~多云 东北风 1-2级 59 良 2
1 2018-01-02 2 -5 阴~多云 东北风 1-2级 49 优 1
2 2018-01-03 2 -5 多云 北风 1-2级 28 优 1
3 2018-01-04 0 -8 阴 东北风 1-2级 28 优 1
4 2018-01-05 3 -6 多云~晴 西北风 1-2级 50 优 1 
dfm.loc[:, 'wencha'] = dfm['bWendu'] - dfm['yWendu']
dfm.head()
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel wencha
0 2018-01-01 3 -6 晴~多云 东北风 1-2级 59 良 2 9
1 2018-01-02 2 -5 阴~多云 东北风 1-2级 49 优 1 7
2 2018-01-03 2 -5 多云 北风 1-2级 28 优 1 7
3 2018-01-04 0 -8 阴 东北风 1-2级 28 优 1 8
4 2018-01-05 3 -6 多云~晴 西北风 1-2级 50 优 1 9

2、df.apply 方法

def get_wendu_type(x):
    if x["bWendu"] > 33:
        return '高温'
    if x["yWendu"] < -10:
        return '低温'
    return '常温'

# 注意需要设置axis==1，这是series的index是columns
dfm.loc[:, "wendu_type"] = dfm.apply(get_wendu_type, axis=1) # 传入函数引用，会自动使用函数
# 统计温度类型
dfm["wendu_type"].value_counts()
常温    328
高温     29
低温      8
Name: wendu_type, dtype: int64

3、df.assign 方法

# 可以同时添加多个新的列
dfm = dfm.assign( # assign 方法不会修改 dfm 而是会返回一个新的 DataFrame 对象
    f_yWendu = lambda x : x["yWendu"] * 9 / 5 + 32,
    # 摄氏度转华氏度
    f_bWendu = lambda x : x["bWendu"] * 9 / 5 + 32
)
dfm.head(5)
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel wencha wendu_type f_yWendu f_bWendu
0 2018-01-01 3 -6 晴~多云 东北风 1-2级 59 良 2 9 常温 21.2 37.4
1 2018-01-02 2 -5 阴~多云 东北风 1-2级 49 优 1 7 常温 23.0 35.6
2 2018-01-03 2 -5 多云 北风 1-2级 28 优 1 7 常温 23.0 35.6
3 2018-01-04 0 -8 阴 东北风 1-2级 28 优 1 8 常温 17.6 32.0
4 2018-01-05 3 -6 多云~晴 西北风 1-2级 50 优 1 9 常温 21.2 37.4

4、按条件选择分组分别赋值

按条件先选择数据，然后对这部分数据赋值新列
实例：高低温差大于10度，则认为温差大

# 先创建空列（这是第一种创建新列的方法）
dfm['wencha_type'] = '' # 广播的方式，指定所有行的指定列的值都是给定的那个值
# 必须先覆盖全，然后进行分组分配值，不然会造成该列的有的位置缺失值
dfm.loc[dfm['bWendu']-dfm['yWendu'] > 10, 'wencha_type'] = '温差大'

dfm.loc[dfm['bWendu']-dfm['yWendu'] <= 10, 'wencha_type'] = '温差正常'
# 统计温差类型列每种类型数量
dfm['wencha_type'].value_counts()
温差正常    187
温差大     178
Name: wencha_type, dtype: int64

pandas 的数据统计方法

  1. 汇总类统计
  2. 唯一去重和按值计数
  3. 相关系数和协方差
# 先看一下前4行
dfm.head(4)
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel wencha wendu_type f_yWendu f_bWendu wencha_type
0 2018-01-01 3 -6 晴~多云 东北风 1-2级 59 良 2 9 常温 21.2 37.4 温差正常
1 2018-01-02 2 -5 阴~多云 东北风 1-2级 49 优 1 7 常温 23.0 35.6 温差正常
2 2018-01-03 2 -5 多云 北风 1-2级 28 优 1 7 常温 23.0 35.6 温差正常
3 2018-01-04 0 -8 阴 东北风 1-2级 28 优 1 8 常温 17.6 32.0 温差正常

1、汇总类统计

# 一下子提取所有数字列的各种数字特征的统计结果，更只管把控全局
dfm.describe()
bWendu yWendu aqi aqiLevel wencha f_yWendu f_bWendu
count 365.000000 365.000000 365.000000 365.000000 365.000000 365.000000 365.000000
mean 18.665753 8.358904 82.183562 2.090411 10.306849 47.046027 65.598356
std 11.858046 11.755053 51.936159 1.029798 2.781233 21.159096 21.344482
min -5.000000 -12.000000 21.000000 1.000000 2.000000 10.400000 23.000000
25% 8.000000 -3.000000 46.000000 1.000000 8.000000 26.600000 46.400000
50% 21.000000 8.000000 69.000000 2.000000 10.000000 46.400000 69.800000
75% 29.000000 19.000000 104.000000 3.000000 12.000000 66.200000 84.200000
max 38.000000 27.000000 387.000000 6.000000 18.000000 80.600000 100.400000 
# 查看单个数字特征-均值
dfm['bWendu'].mean()
18.665753424657535
# 查看单个数字特征-最大值
dfm[['bWendu', 'yWendu']].max()
bWendu    38
yWendu    27
dtype: int32
# 查看单个数字特征-最小值
dfm['wencha'].min()
2

2、唯一去重和按值计数

唯一去重，适合列出有哪些，不多的枚举

dfm["fengxiang"].unique()
array(['东北风', '北风', '西北风', '西南风', '南风', '东南风', '东风', '西风'], dtype=object)
dfm["tianqi"].unique()
array(['晴~多云', '阴~多云', '多云', '阴', '多云~晴', '多云~阴', '晴', '阴~小雪', '小雪~多云',
       '小雨~阴', '小雨~雨夹雪', '多云~小雨', '小雨~多云', '大雨~小雨', '小雨', '阴~小雨',
       '多云~雷阵雨', '雷阵雨~多云', '阴~雷阵雨', '雷阵雨', '雷阵雨~大雨', '中雨~雷阵雨', '小雨~大雨',
       '暴雨~雷阵雨', '雷阵雨~中雨', '小雨~雷阵雨', '雷阵雨~阴', '中雨~小雨', '小雨~中雨', '雾~多云',
       '霾'], dtype=object)
dfm["fengli"].unique()
array(['1-2级', '4-5级', '3-4级', '2级', '1级', '3级'], dtype=object)

按值计数

dfm["fengxiang"].value_counts()
南风     92
西南风    64
北风     54
西北风    51
东南风    46
东北风    38
东风     14
西风      6
Name: fengxiang, dtype: int64
dfm["tianqi"].value_counts()
晴         101
多云         95
多云~晴       40
晴~多云       34
多云~雷阵雨     14
多云~阴       10
小雨~多云       8
雷阵雨         8
阴~多云        8
雷阵雨~多云      7
小雨          6
多云~小雨       5
雷阵雨~中雨      4
阴           4
中雨~雷阵雨      2
阴~小雨        2
中雨~小雨       2
霾           2
雷阵雨~阴       1
雷阵雨~大雨      1
小雨~雷阵雨      1
小雨~大雨       1
雾~多云        1
小雪~多云       1
阴~雷阵雨       1
小雨~中雨       1
小雨~阴        1
暴雨~雷阵雨      1
小雨~雨夹雪      1
阴~小雪        1
大雨~小雨       1
Name: tianqi, dtype: int64
dfm["fengli"].value_counts()
1-2级    236
3-4级     68
1级       21
4-5级     20
2级       13
3级        7
Name: fengli, dtype: int64

3、相关系数和协方差

用途（超级厉害）：

  1. 两只股票，是不是同涨同跌？程度多大？正相关还是负相关？
  2. 产品销量的波动，跟哪些因素正相关、负相关，程度有多大？

来自知乎，对于两个变量X、Y：

  1. 协方差：衡量同向反向程度，如果协方差为正，说明X，Y同向变化，协方差越大说明同向程度越高；如果协方差为负，说明X，Y反向运动，协方差越小说明反向程度越高。
  2. 相关系数：衡量相似度程度，当他们的相关系数为1时，说明两个变量变化时的正向相似度最大，当相关系数为－1时，说明两个变量变化的反向相似度最大
# 协方差矩阵：
dfm.cov()
bWendu yWendu aqi aqiLevel wencha f_yWendu f_bWendu
bWendu 140.613247 135.529633 47.462622 0.879204 5.083614 243.953339 253.103845
yWendu 135.529633 138.181274 16.186685 0.264165 -2.651641 248.726292 243.953339
aqi 47.462622 16.186685 2697.364564 50.749842 31.275937 29.136033 85.432720
aqiLevel 0.879204 0.264165 50.749842 1.060485 0.615038 0.475498 1.582567
wencha 5.083614 -2.651641 31.275937 0.615038 7.735255 -4.772953 9.150506
f_yWendu 243.953339 248.726292 29.136033 0.475498 -4.772953 447.707326 439.116010
f_bWendu 253.103845 243.953339 85.432720 1.582567 9.150506 439.116010 455.586920 
# 单独查看空气质量和最高温度的相关系数
dfm["aqi"].corr(dfm["bWendu"])
0.07706705916811067
dfm["aqi"].corr(dfm["yWendu"])
0.026513282672968895
# 空气质量和温差的相关系数-看到了明显提升的相关系数-数据挖掘出了信息-空气质量和温差有关系
dfm["aqi"].corr(dfm["bWendu"] - dfm["yWendu"])
0.2165225757638205
# !! 这就是特征工程对于机器学习重要性的一个例子

Pandas对缺失值的处理

Pandas使用这些函数处理缺失值：

  • isnull和notnull：检测是否是空值，可用于df和series
  • dropna：丢弃、删除缺失值
    • axis : 删除行还是列，{0 or ‘index’, 1 or ‘columns’}, default 0
    • how : 如果等于any则任何值为空都删除，如果等于all则所有值都为空才删除
    • inplace : 如果为True则修改当前df，否则返回新的df
  • fillna：填充空值
    • value：用于填充的值，可以是单个值，或者字典（key是列名，value是值）
    • method : 等于ffill使用前一个不为空的值填充forword fill；等于bfill使用后一个不为空的值填充backword fill
    • axis : 按行还是列填充，{0 or ‘index’, 1 or ‘columns’}
    • inplace : 如果为True则修改当前df，否则返回新的df

读取excel的时候，忽略前几个空行 skiprows 参数控制

studf = pd.read_excel('./datas/student_excel/student_excel.xlsx', skiprows=2)
studf.head(10)
Unnamed: 0 姓名 科目 分数
0 NaN 小明 语文 85.0
1 NaN NaN 数学 80.0
2 NaN NaN 英语 90.0
3 NaN NaN NaN NaN
4 NaN 小王 语文 85.0
5 NaN NaN 数学 NaN
6 NaN NaN 英语 90.0
7 NaN NaN NaN NaN
8 NaN 小刚 语文 85.0
9 NaN NaN 数学 80.0

检测空值

studf.isnull().head()
Unnamed: 0 姓名 科目 分数
0 True False False False
1 True True False False
2 True True False False
3 True True True True
4 True False False False 
# 查看单列的空缺情况
studf['分数'].isnull().head()
0    False
1    False
2    False
3     True
4    False
Name: 分数, dtype: bool
# 使用notnull查看非空的
studf['分数'].notnull().head()
0     True
1     True
2     True
3    False
4     True
Name: 分数, dtype: bool
# 筛选没有空分的行-这一步的目的是大致观察清晰的数据
studf.loc[studf['分数'].notnull(), :].head(10)
Unnamed: 0 姓名 科目 分数
0 NaN 小明 语文 85.000000
1 NaN NaN 数学 80.000000
2 NaN NaN 英语 90.000000
4 NaN 小王 语文 85.000000
6 NaN NaN 英语 90.000000
8 NaN 小刚 语文 85.000000
9 NaN NaN 数学 80.000000
10 NaN NaN 英语 90.000000
11 NaN 小啊 语文 86.507353
12 NaN NaN 数学 86.654412

删除全是空值的列

studf.dropna(axis=1,how='all' ,inplace=True)
studf.head(10)
姓名 科目 分数
0 小明 语文 85.0
1 NaN 数学 80.0
2 NaN 英语 90.0
3 NaN NaN NaN
4 小王 语文 85.0
5 NaN 数学 NaN
6 NaN 英语 90.0
7 NaN NaN NaN
8 小刚 语文 85.0
9 NaN 数学 80.0

删除全是空值的行

studf.dropna(axis=0, how='all', inplace=True)
studf.head(10)
姓名 科目 分数
0 小明 语文 85.000000
1 NaN 数学 80.000000
2 NaN 英语 90.000000
4 小王 语文 85.000000
5 NaN 数学 NaN
6 NaN 英语 90.000000
8 小刚 语文 85.000000
9 NaN 数学 80.000000
10 NaN 英语 90.000000
11 小啊 语文 86.507353

把分数为空的填充为0

studf['分数'].fillna(0, inplace=True) # 无返回df，直接操作源内村
# studf.fillna({'分数': 0}, inplace=True) # 无返回df，直接操作原内存
# studf.loc[:, '分数'] = studf.fillna({'分数': 0}) # 有返回df
# studf.loc[:, '分数'] = studf['分数'].fillna(0) # 有返回df
# 以上为等效的方法
studf.head(10)
姓名 科目 分数
0 小明 语文 85.000000
1 NaN 数学 80.000000
2 NaN 英语 90.000000
4 小王 语文 85.000000
5 NaN 数学 0.000000
6 NaN 英语 90.000000
8 小刚 语文 85.000000
9 NaN 数学 80.000000
10 NaN 英语 90.000000
11 小啊 语文 86.507353

将姓名的缺失值填充为上一个

# 参数 ffill代表用上面的值填充，dfill代表用下面的值填充
studf.loc[:, '姓名'] = studf['姓名'].fillna(method="ffill") # 返回填充后的列，赋值给原来的列
# studf['姓名'] = studf['姓名'].fillna(method='ffill')
# studf['姓名'].fillna(method='ffill', inplace=True)
# 以上三种形式等效
studf.head(10)
姓名 科目 分数
0 小明 语文 85.000000
1 小明 数学 80.000000
2 小明 英语 90.000000
4 小王 语文 85.000000
5 小王 数学 0.000000
6 小王 英语 90.000000
8 小刚 语文 85.000000
9 小刚 数学 80.000000
10 小刚 英语 90.000000
11 小啊 语文 86.507353

将清洗好的数据写入excel文件

studf.to_excel('./datas/student_excel/student_excel_clean.xlsx', index=False) # 舍弃索引列

pandas数据排序

Series的排序：
Series.sort_values(ascending=True, inplace=False)
参数说明：

  • ascending：默认为True升序排序，为False降序排序
  • inplace：是否修改原始Series

DataFrame的排序：
DataFrame.sort_values(by, ascending=True, inplace=False)
参数说明：

  • by：字符串或者List <字符串> ，单列排序或者多列排序
  • ascending：bool或者List ，升序还是降序，如果是list对应by的多列
  • inplace：是否修改原始DataFrame
df4 = pd.read_csv('./datas/beijing_tianqi/beijing_tianqi_2018.csv')
# 替换掉温度的后缀℃
df4.loc[:, 'bWendu'] = df4['bWendu'].str.replace('℃', '').astype('int32')
df4.loc[:, 'yWendu'] = df4['yWendu'].str.replace('℃', '').astype('int32')
df4.head()
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
0 2018-01-01 3 -6 晴~多云 东北风 1-2级 59 良 2
1 2018-01-02 2 -5 阴~多云 东北风 1-2级 49 优 1
2 2018-01-03 2 -5 多云 北风 1-2级 28 优 1
3 2018-01-04 0 -8 阴 东北风 1-2级 28 优 1
4 2018-01-05 3 -6 多云~晴 西北风 1-2级 50 优 1

Series 的排序

按照空气质量排序

# 默认ascending为True代表升序
df4['aqi'].sort_values().head(10) # 也可以指定inplace=True代表在源内存上改
271    21
281    21
249    22
272    22
301    22
246    24
35     24
33     24
10     24
273    25
Name: aqi, dtype: int64
# 下面我们按照降序排序
df4['aqi'].sort_values(ascending=False).head(10) # sort_values 返回结果副本，也可指定inplace
86     387
72     293
91     287
71     287
317    266
329    245
85     243
335    234
57     220
316    219
Name: aqi, dtype: int64
# 按照内部机制排序
df4['tianqi'].sort_values().head(10)
225     中雨~小雨
230     中雨~小雨
197    中雨~雷阵雨
196    中雨~雷阵雨
112        多云
108        多云
232        多云
234        多云
241        多云
94         多云
Name: tianqi, dtype: object

DataFrame 的排序

单列排序

df4.sort_values(by='aqi').head(7) # 按照空气质量升序
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
271 2018-09-29 22 11 晴 北风 3-4级 21 优 1
281 2018-10-09 15 4 多云~晴 西北风 4-5级 21 优 1
249 2018-09-07 27 16 晴 西北风 3-4级 22 优 1
272 2018-09-30 19 13 多云 西北风 4-5级 22 优 1
301 2018-10-29 15 3 晴 北风 3-4级 22 优 1
246 2018-09-04 31 18 晴 西南风 3-4级 24 优 1
35 2018-02-05 0 -10 晴 北风 3-4级 24 优 1 
df4.sort_values(by='aqi', ascending=False).head(7) # 按照空气质量降序
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
86 2018-03-28 25 9 多云~晴 东风 1-2级 387 严重污染 6
72 2018-03-14 15 6 多云~阴 东北风 1-2级 293 重度污染 5
71 2018-03-13 17 5 晴~多云 南风 1-2级 287 重度污染 5
91 2018-04-02 26 11 多云 北风 1-2级 287 重度污染 5
317 2018-11-14 13 5 多云 南风 1-2级 266 重度污染 5
329 2018-11-26 10 0 多云 东南风 1级 245 重度污染 5
85 2018-03-27 27 11 晴 南风 1-2级 243 重度污染 5

多列排序------显然返回的是df

# 优先按照空气质量等级，次按照最高温排序，默认ascending=True 即[两列都是升序]
df4.sort_values(by=['aqiLevel', 'bWendu']).head(7)
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
360 2018-12-27 -5 -12 多云~晴 西北风 3级 48 优 1
22 2018-01-23 -4 -12 晴 西北风 3-4级 31 优 1
23 2018-01-24 -4 -11 晴 西南风 1-2级 34 优 1
340 2018-12-07 -4 -10 晴 西北风 3级 33 优 1
21 2018-01-22 -3 -10 小雪~多云 东风 1-2级 47 优 1
24 2018-01-25 -3 -11 多云 东北风 1-2级 27 优 1
25 2018-01-26 -3 -10 晴~多云 南风 1-2级 39 优 1 
# [两列都是降序]
df4.sort_values(by=['aqiLevel', 'bWendu']).head(7)
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
360 2018-12-27 -5 -12 多云~晴 西北风 3级 48 优 1
22 2018-01-23 -4 -12 晴 西北风 3-4级 31 优 1
23 2018-01-24 -4 -11 晴 西南风 1-2级 34 优 1
340 2018-12-07 -4 -10 晴 西北风 3级 33 优 1
21 2018-01-22 -3 -10 小雪~多云 东风 1-2级 47 优 1
24 2018-01-25 -3 -11 多云 东北风 1-2级 27 优 1
25 2018-01-26 -3 -10 晴~多云 南风 1-2级 39 优 1 
# [分别指定升序和降序] ascending传入列表[True, None] None等效False
df4.sort_values(by=['aqiLevel', 'bWendu'], ascending=[True, False]).head(7)
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
178 2018-06-28 35 24 多云~晴 北风 1-2级 33 优 1
149 2018-05-30 33 18 晴 西风 1-2级 46 优 1
206 2018-07-26 33 25 多云~雷阵雨 东北风 1-2级 40 优 1
158 2018-06-08 32 19 多云~雷阵雨 西南风 1-2级 43 优 1
205 2018-07-25 32 25 多云 北风 1-2级 28 优 1
226 2018-08-15 32 24 多云 东北风 3-4级 33 优 1
231 2018-08-20 32 23 多云~晴 北风 1-2级 41 优 1

Pandas字符串处理

使用.str转换之后就可以使用python内置的各种字符串处理方法，当然这是pandas封装的，甚至还比标准库多

前面我们已经使用了字符串的处理函数：
df["bWendu"].str.replace("℃", "").astype('int32')

Pandas的字符串处理：

  1. 使用方法：先获取Series的str属性，然后在属性上调用函数；
  2. 只能在字符串列上使用，不能数字列上使用；
  3. Dataframe上没有str属性和处理方法
  4. Series.str并不是Python原生字符串，而是自己的一套方法，不过大部分和原生str很相似；

Series.str字符串方法列表参考文档:
https://pandas.pydata.org/pandas-docs/stable/reference/series.html#string-handling

本节演示内容：

  1. 获取Series的str属性，然后使用各种字符串处理函数
  2. 使用str的startswith、contains等bool类Series可以做条件查询
  3. 需要多次str处理的链式操作
  4. 使用正则表达式的处理
df5 = pd.read_csv("./datas/beijing_tianqi/beijing_tianqi_2018.csv")
df5.head(7)
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
0 2018-01-01 3℃ -6℃ 晴~多云 东北风 1-2级 59 良 2
1 2018-01-02 2℃ -5℃ 阴~多云 东北风 1-2级 49 优 1
2 2018-01-03 2℃ -5℃ 多云 北风 1-2级 28 优 1
3 2018-01-04 0℃ -8℃ 阴 东北风 1-2级 28 优 1
4 2018-01-05 3℃ -6℃ 多云~晴 西北风 1-2级 50 优 1
5 2018-01-06 2℃ -5℃ 多云~阴 西南风 1-2级 32 优 1
6 2018-01-07 2℃ -4℃ 阴~多云 西南风 1-2级 59 良 2 
df5.dtypes
ymd          object
bWendu       object
yWendu       object
tianqi       object
fengxiang    object
fengli       object
aqi           int64
aqiInfo      object
aqiLevel      int64
dtype: object

1、获取Series的str属性，使用各种字符串处理函数

# 判断是不是数字的
df5['bWendu'].str.isnumeric().value_counts()
False    365
Name: bWendu, dtype: int64
df5['bWendu'].str.isnumeric().head()
0    False
1    False
2    False
3    False
4    False
Name: bWendu, dtype: bool
# 不可以使用这样的 df5['aqi'].str.len()

2、使用str的startswith、contains等得到bool的Series可以做条件查询

# 条件是以'2018-03'开头 也就是查询了2018年3月的
condition = df5["ymd"].str.startswith("2018-03") 
condition.head() # 前面都是False 到了2018-03就是True了 bool对应关系图
0    False
1    False
2    False
3    False
4    False
Name: ymd, dtype: bool
df5.loc[condition, :].head(7) # 查询三月的
# df5.loc[condition].head(7) # 等效方法
# df5[condition].head(7) # 等效方法
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
59 2018-03-01 8℃ -3℃ 多云 西南风 1-2级 46 优 1
60 2018-03-02 9℃ -1℃ 晴~多云 北风 1-2级 95 良 2
61 2018-03-03 13℃ 3℃ 多云~阴 北风 1-2级 214 重度污染 5
62 2018-03-04 7℃ -2℃ 阴~多云 东南风 1-2级 144 轻度污染 3
63 2018-03-05 8℃ -3℃ 晴 南风 1-2级 94 良 2
64 2018-03-06 6℃ -3℃ 多云~阴 东南风 3-4级 67 良 2
65 2018-03-07 6℃ -2℃ 阴~多云 北风 1-2级 65 良 2

3、需要多次str处理的链式操作

怎样提取201803这样的数字月份？
1、replace 先将日期2018-03-31替换成20180331的形式
2、提取月份字符串201803

df5['ymd'].str.replace('-', '').head(7)
0    20180101
1    20180102
2    20180103
3    20180104
4    20180105
5    20180106
6    20180107
Name: ymd, dtype: object
# 每次调用函数，都返回一个新Series，需要再次用 `.str`操作才能继续使用字符串操作方法
# df5["ymd"].str.replace("-", "").slice(0, 6) # 将会报错
df5['ymd'].str.replace('-', '').str.slice(0, 6).head()
# slice方法其实就是切片语法，直接[::]就可
# df5['ymd'].str.replace('-', '').str[0:6]
0    201801
1    201801
2    201801
3    201801
4    201801
Name: ymd, dtype: object

4、使用正则表达式的处理

首先不使用的情况是这样的

# 添加新列-如 2018年03月14日
def get_nianyueri(x):
    year, month, day = x["ymd"].split("-")
    return f"{year}年{month}月{day}日"
df5["中文日期"] = df5.apply(get_nianyueri, axis=1)
df5["中文日期"].head()
0    2018年01月01日
1    2018年01月02日
2    2018年01月03日
3    2018年01月04日
4    2018年01月05日
Name: 中文日期, dtype: object
# 链式操作，每次调用字符串处理方法都要先 `.str`
df5['中文日期'].str.replace('年', '').str.replace('月', '').str.replace('日', '').head()
0    20180101
1    20180102
2    20180103
3    20180104
4    20180105
Name: 中文日期, dtype: object

然后是Series.str默认就开启了正则表达式模式的情况是这样的

# 正则表达式匹配替换-'[年月日]'中括号内每一个字符都匹配
df5['中文日期'].str.replace('[年月日]', '').head()
0    20180101
1    20180102
2    20180103
3    20180104
4    20180105
Name: 中文日期, dtype: object

理解axis参数

axis=0或'index' 跨行梳出

axis=1或'columns' 跨列梳出

后续篇目

猜你喜欢

转载自www.cnblogs.com/runtu/p/11625801.html
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
NEFU 117 素数个数的位数
Closest Common Ancestors (Lca,tarjan)
ELK部署
【转载】Hive笔记整理（三）
SQL语句（一）基本表的定义
关于Java web开发中的MySQL的事务语句
MFC创建自定义窗体
如何用一句话激怒程序员？
《逆袭大学》文摘——9.4 基础和应用的平衡中找到大学的节奏
【spring源码分析】@Value注解原理
每日归档
更多
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022