datawhale8月组队学习《pandas数据处理与分析》(下)(文本、分类、时序数据)
文章目录
- 第八章 文本数据
- 8.1 str对象
- 8.1.1 str对象的设计意图
- 8.1.3 string类型
- 8.2 正则表达式基础
- 8.2.1 . 一般字符的匹配
- 8.2.2 元字符基础
- 8.2.3 简写字符集
- 8.3 文本处理的五类操作
- 8.3.1 `str.split `拆分
- 8.3.2 `str.join` 或 `str.cat `合并
- 8.3.3 匹配
- 8.3.5 提取
- 8.4、常用字符串函数
- 8.4.1 字母型函数
- 8.4.2 数值型函数
- 8.4.3 统计型函数
- 8.4.4 格式型函数
- 8.5 练习
- Ex1:房屋信息数据集
- Ex2:《权力的游戏》剧本数据集
- 第九章 分类数据
- 9.1 cat对象
- 9.1.1 cat对象的属性
- 9.1.2 类别的增加、删除和修改
- 9.2 有序分类
- 9.2.1 序的建立
- 9.2.2 排序和比较
- 9.3 区间类别
- 9.3.1 利用cut和qcut进行区间构造
- 9.3.2 一般区间的构造
- 9.3.3 区间的属性与方法
- 9.4 练习
- Ex1: 统计未出现的类别
- Ex2: 钻石数据集
- 第十章 时序数据
- 10.1 时序中的基本对象
- 10.2 时间戳
- 10.2.1 Timestamp的构造与属性
- 10.2.2 Datetime序列的生成
- 10.2.3 dt对象
- 10.2.4 时间戳的切片与索引
- 10.3 时间差
- 10.3.1 Timedelta的生成
- 10.2.2 Timedelta的运算
- 10.4 日期偏置
- 10.4.1 Offset对象
- 10.4.2 偏置字符串
- 10.5、时序中的滑窗与分组
- 10.5.1 滑动窗口
- 10.5.2 重采样
- 10.6 练习
- Ex1:太阳辐射数据集
- Ex2:水果销量数据集
课程资料《pandas数据处理与分析》、github地址、讲解视频、习题参考答案 、pandas官网
传送门:
- datawhale8月组队学习《pandas数据处理与分析》(上)(基础、索引、分组)
- datawhale8月组队学习《pandas数据处理与分析》(中)(变形、连接、缺失数据)
第八章 文本数据
8.1 str对象
8.1.1 str对象的设计意图
str
对象是定义在 Index
或 Series
上的属性,专门用于处理每个元素的文本内容,其内部定义了大量方法,因此对一个序列进行文本处理,首先需要获取其 str
对象。在Python标准库中也有 str
模块,为了使用上的便利,在 pandas 的50个 str
对象方法中,有31个是和标准库中的 str
模块方法同名且功能一致,例如字母转为大写的操作:
var = 'abcd'
str.upper(var) # Python内置str模块
Out[4]: 'ABCD's = pd.Series(['abcd', 'efg', 'hi'])s.str
Out[6]: <pandas.core.strings.accessor.StringMethods at 0x2b796892d60>s.str.upper() # pandas中str对象上的upper方法
Out[7]:
0 ABCD
1 EFG
2 HI
dtype: object
8.1.2 []索引器
对于 str 对象而言,可理解为其对字符串进行了序列化的操作,例如在一般的字符串中,通过 [] 可以取出某个位置的元素,同时也能通过切片得到子串。
pandas中过对 str
对象使用 [] 索引器,可以完成完全一致的功能,并且如果超出范围则返回缺失值:
s.str[0]
Out[10]:
0 a
1 e
2 h
dtype: objects.str[-1: 0: -2]
Out[11]:
0 db
1 g
2 i
dtype: objects.str[2]
Out[12]:
0 c
1 g
2 NaN
dtype: object
import numpy as np
import pandas as pds = pd.Series(['abcd', 'efg', 'hi'])
s.str[0]
0 a
1 e
2 h
dtype: object
8.1.3 string类型
在上一章提到,从 pandas 的 1.0.0 版本开始,引入了 string 类型,其引入的动机在于:原来所有的字符串类型都会以 object 类型的 Series 进行存储,但 object 类型只应当存储混合类型,例如同时存储浮点、字符串、字典、列表、自定义类型等,因此字符串有必要同数值型或 category 一样,具有自己的数据存储类型,从而引入了 string 类型。
总体上说,绝大多数对于 object 和 string 类型的序列使用 str 对象方法产生的结果是一致,但是在下面提到的两点上有较大差异:
- 二者对于某些对象的 str 序列化方法不同。
可迭代(Iterable)对象包括但不限于字符串、字典、列表。对于一个可迭代对象,string
类型和object
类型对它们的序列化方式不同,序列化后str
对象返回结果也可能不同。例如:
s = pd.Series([{1: 'temp_1', 2: 'temp_2'}, ['a', 'b'], 0.5, 'my_string'])
s
0 {1: 'temp_1', 2: 'temp_2'}
1 [a, b]
2 0.5
3 my_string
dtype: object
s.str[1] # 对每个元素取[1]的操作
0 temp_1
1 b
2 NaN
3 y
dtype: object
s.astype('string').str[1]
0 1
1 '
2 .
3 y
dtype: string
除了最后一个字符串元素,前三个元素返回的值都不同,其原因在于:
- 当序列类型为
object
时,是对于每一个元素进行 [] 索引,因此对于字典而言,返回temp_1字符串,对于列表则返回第二个值,而第三个为不可迭代对象,返回缺失值,第四个是对字符串进行 [] 索引。 - string 类型的
str
对象先把整个元素转为字面意义的字符串,例如对于列表而言,第一个元素即 “{”,而对于最后一个字符串元素而言,恰好转化前后的表示方法一致,因此结果和object
类型一致。
- string 类型是 Nullable 类型,但 object 不是
这意味着 string 类型的序列,如果调用的 str 方法返回值为整数 Series 和布尔 Series 时,其分别对应的 dtype 是 Int 和 boolean 的 Nullable 类型,而 object 类型则会分别返回 int/float 和 bool/object ,不过这取决于缺失值的存在与否。
同时,字符串的比较操作,也具有相似的特性, string 返回 Nullable 类型,但 object 不会。
s = pd.Series(['a'])s.str.len()
Out[17]:
0 1
dtype: int64s.astype('string').str.len()
Out[18]:
0 1
dtype: Int64s == 'a'
Out[19]:
0 True
dtype: bools.astype('string') == 'a'
Out[20]:
0 True
dtype: booleans = pd.Series(['a', np.nan]) # 带有缺失值s.str.len()
Out[22]:
0 1.0
1 NaN
dtype: float64s.astype('string').str.len()
Out[23]:
0 1
1 <NA>
dtype: Int64s == 'a'
Out[24]:
0 True
1 False
dtype: bools.astype('string') == 'a'
Out[25]:
0 True
1 <NA>
dtype: boolean
对于全体元素为数值类型的序列,即使其类型为 object 或者 category 也不允许直接使用 str 属性。如果需要把数字当成 string 类型处理,可以使用 astype 强制转换为 string 类型的 Series :
s = pd.Series([12, 345, 6789])s.astype('string').str[1]
Out[27]:
0 2
1 4
2 7
dtype: string
8.2 正则表达式基础
这一节的两个表格来自于 learn-regex-zh 这个关于正则表达式项目,其使用 MIT 开源许可协议。这里只是介绍正则表达式的基本用法,需要系统学习的读者可参考《Python3 正则表达式》,或者《 正则表达式必知必会 》这本书
8.2.1 . 一般字符的匹配
正则表达式是一种按照某种正则模式,从左到右匹配字符串中内容的一种工具。对于一般的字符而言,它可以找到其所在的位置,这里为了演示便利,使用了 python 中 re 模块的 findall
函数来匹配所有出现过但不重叠的模式,第一个参数是正则表达式,第二个参数是待匹配的字符串。例如,在下面的字符串中找出 apple :
import rere.findall(r'Apple', 'Apple! This Is an Apple!') # 字符串从左到右依次匹配
Out[29]: ['Apple', 'Apple']
8.2.2 元字符基础
元字符 | 描述 |
---|---|
. | 匹配除换行符以外的任意字符 |
[ ] | 字符类,匹配方括号中包含的任意字符 |
[^ ] | 否定字符类,匹配方括号中不包含的任意字符 |
* | 匹配前面的子表达式零次或多次 |
+ | 匹配前面的子表达式一次或多次。比如r’d+'就是匹配数字串,r’d’就是匹配单个数字 |
? | 匹配前面的子表达式零次或一次,非贪婪方式 |
{n,m} | 花括号,匹配 n 到 m 次由前面的正则表达式定义的片段,贪婪方式 |
(xyz) | 字符组,按照确切的顺序匹配字符xyz |
| | 分支结构,匹配符号之前的字符或后面的字符 |
\ | 转义符,它可以还原元字符原来的含义 |
^ | 匹配行的开始 |
$ | 匹配行的结束 |
import re
re.findall(r'.', 'abc')
Out[30]: ['a', 'b', 'c']re.findall(r'[ac]', 'abc') # []中有的子串都匹配
Out[31]: ['a', 'c']re.findall(r'[^ac]', 'abc')
Out[32]: ['b']re.findall(r'[ab]{2}', 'aaaabbbb') # {n}指匹配n次
Out[33]: ['aa', 'aa', 'bb', 'bb']re.findall(r'aaa|bbc|ca', 'aacabbcbbc') # 匹配前面的或者后面的字符串
Out[34]: ['ca', 'bbc', 'bbc']# 上面的元字符都有特殊含义,要匹配其本来的意思就得用\进行转义。
"""
1. ?匹配的是前一个字符,即被转义的\,所以|前面的内容就是匹配a\或者a,但是结果里面没有a\,相当于只能匹配a。
2. |右边是a\*,转义之后匹配a*,对于竖线而言左边优先级高于右边
3. 然后看目标字符串aa?a*a,第一个a匹配左边,第二个a匹配左边,第三个a虽然后面有*,
但是左边优先级高, 还是匹配左边,剩下一个a还是左边,所以结果是四个a
"""re.findall(r'a\\?|a\*', 'aa?a*a') # 第二次先匹配到a,就不会匹配a?。a*同理。
Out[35]: ['a', 'a', 'a', 'a']# 这里匹配不到是因为目标串'aa\a*a'中,\a是python的转义字符(\a\b\t\n等),所以匹配不到。
# 如果是'aa\s*a'之内非python的转义字符,或者'aa\\s*a',或者r'aa\\s*a'就可以匹配到\字符。
re.findall(r'\\', 'aa\a*a')
[]re.findall(r'a?.', 'abaacadaae')
Out[36]: ['ab', 'aa', 'c', 'ad', 'aa', 'e']re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10') # 多个匹配模式,返回元组列表
[('width', '20'), ('height', '10')]
8.2.3 简写字符集
则表达式中还有一类简写字符集,其等价于一组字符的集合:
简写 | 描述 |
---|---|
\w | 匹配所有字母、数字、下划线: [a-zA-Z0-9_] |
\W | 匹配非字母和数字的字符: [^\w] |
\d | 匹配数字: [0-9] |
\D | 匹配非数字: [^\d] |
\s | 匹配空格符: [\t\n\f\r\p{Z}] |
\S | 匹配非空格符: [^\s] |
\B | 匹配非单词边界。‘er\B’ 能匹配 “verb” 中的 ‘er’,但不能匹配 “never” 中的 ‘er’。 |
re.findall(r'.s', 'Apple! This Is an Apple!')
Out[37]: ['is', 'Is']re.findall(r'\w{2}', '09 8? 7w c_ 9q p@') # 匹配任意数字字母下划线的组合,但必须是两次
Out[38]: ['09', '7w', 'c_', '9q']re.findall(r'\w\W\B', '09 8? 7w c_ 9q p@') # 匹配的是两个字符串,前一个是任意数字字母下划线(\W),后一个不是(\W)
Out[39]: ['8?', 'p@']re.findall(r'.\s.', 'Constant dropping wears the stone.')
Out[40]: ['t d', 'g w', 's t', 'e s']re.findall(r'上海市(.{2,3}区)(.{2,3}路)(\d+号)','上海市黄浦区方浜中路249号 上海市宝山区密山路5号')Out[41]: [('黄浦区', '方浜中路', '249号'), ('宝山区', '密山路', '5号')]
8.3 文本处理的五类操作
8.3.1 str.split
拆分
str.split
能够把字符串的列进行拆分,其中第一个参数为正则表达式,可选参数包括从左到右的最大拆分次数 n ,是否展开为多个列 expand 。
s = pd.Series(['上海市黄浦区方浜中路249号','上海市宝山区密山路5号'])s.str.split('[市区路]') # 每条结果为一行,相当于Series
Out[43]:
0 [上海, 黄浦, 方浜中, 249号]
1 [上海, 宝山, 密山, 5号]
dtype: objects.str.split('[市区路]', n=2, expand=True) # 结果分成多个列展示,结果相当于DataFrame
Out[44]: 0 1 2
0 上海 黄浦 方浜中路249号
1 上海 宝山 密山路5号
类似的函数是 str.rsplit
,其区别在于使用 n 参数的时候是从右到左限制最大拆分次数。但是当前版本下 rsplit 因为 bug 而无法使用正则表达式进行分割:
s.str.rsplit('[市区路]', n=2, expand=True)
Out[45]: 0
0 上海市黄浦区方浜中路249号
1 上海市宝山区密山路5号
8.3.2 str.join
或 str.cat
合并
str.join
表示用某个连接符把 Series 中的字符串列表连接起来,如果列表中出现了非字符串元素则返回缺失值。str.cat
用于合并两个序列,主要参数为:- sep:连接符、
- join:连接形式默认为以索引为键的左连接
- na_rep:缺失值替代符号
s = pd.Series([['a','b'], [1, 'a'], [['a', 'b'], 'c']])
s.str.join('-')
Out[47]:
0 a-b
1 NaN
2 NaN
dtype: object
s1 = pd.Series(['a','b'])
s2 = pd.Series(['cat','dog'])
s1.str.cat(s2,sep='-')
Out[50]:
0 a-cat
1 b-dog
dtype: objects2.index = [1, 2]
s1.str.cat(s2, sep='-', na_rep='?', join='outer')
Out[52]:
0 a-?
1 b-cat
2 ?-dog
dtype: object
8.3.3 匹配
str.contains
返回了每个字符串是否包含正则模式的布尔序列:
s = pd.Series(['my cat', 'he is fat', 'railway station'])
s.str.contains('\s\wat')0 True
1 True
2 False
dtype: bool
str.startswith
和str.endswith
返回了每个字符串以给定模式为开始和结束的布尔序列,它们都不支持正则表达式:
s.str.startswith('my')0 True
1 False
2 False
dtype: bool
s.str.endswith('t')0 True
1 True
2 False
dtype: bool
str.match
可以用正则表达式来检测开始或结束字符串的模式,其返回了每个字符串起始处是否符合给定正则模式的布尔序列。当然,这些也能通过在str.contains
的正则中使用^
和$
来实现。(貌似没有python里的search方法)
s.str.match('m|h')
s.str.contains('^[m|h]') # 二者等价0 True
1 True
2 False
dtype: bool
s.str[::-1].str.match('ta[f|g]|n') # 反转后匹配
s.str.contains('[f|g]at|n$') # 二者等价0 False
1 True
2 True
dtype: bool
str.find
与str.rfind
返回索引的匹配函数,其分别返回从左到右和从右到左第一次匹配的位置的索引,未找到则返回-1。需要注意的是这两个函数不支持正则匹配,只能用于字符子串的匹配:
s = pd.Series(['This is an apple. That is not an apple.'])s.str.find('apple')
Out[62]:
0 11
dtype: int64s.str.rfind('apple')
Out[63]:
0 33
dtype: int64
- 替换
str.replace
和replace
并不是一个函数,在使用字符串替换时应当使用前者。
s = pd.Series(['a_1_b','c_?'])
# regex默认为True,表示是正则模式,否则第一个参数内容表示是单纯的字符串,也就是匹配字符串\d|\?
s.str.replace('\d|\?', 'new', regex=True) 0 a_new_b
1 c_new
dtype: object
当需要对不同部分进行有差别的替换时,可以利用子组
的方法,并且此时可以通过传入自定义的替换函数来分别进行处理,注意group(k)
代表匹配到的第k
个子组(圆括号之间的内容):
s = pd.Series(['上海市黄浦区方浜中路249号','上海市宝山区密山路5号','北京市昌平区北农路2号'])
pat = '(\w+市)(\w+区)(\w+路)(\d+号)'
city = {'上海市': 'Shanghai', '北京市': 'Beijing'}
district = {'昌平区': 'CP District','黄浦区': 'HP District','宝山区': 'BS District'}
road = {'方浜中路': 'Mid Fangbin Road','密山路': 'Mishan Road','北农路': 'Beinong Road'}
def my_func(m):str_city = city[m.group(1)]str_district = district[m.group(2)]str_road = road[m.group(3)]str_no = 'No. ' + m.group(4)[:-1]return ' '.join([str_city,str_district,str_road,str_no])
s.str.replace(pat, my_func, regex=True)
0 Shanghai HP District Mid Fangbin Road No. 249
1 Shanghai BS District Mishan Road No. 5
2 Beijing CP District Beinong Road No. 2
dtype: object
这里的数字标识并不直观,可以使用命名子组
更加清晰地写出子组代表的含义:
# 将各个子组进行命名
pat = '(?P<市名>\w+市)(?P<区名>\w+区)(?P<路名>\w+路)(?P<编号>\d+号)'
def my_func(m):str_city = city[m.group('市名')]str_district = district[m.group('区名')]str_road = road[m.group('路名')]str_no = 'No. ' + m.group('编号')[:-1]return ' '.join([str_city,str_district,str_road,str_no])
s.str.replace(pat, my_func, regex=True)
0 Shanghai HP District Mid Fangbin Road No. 249
1 Shanghai BS District Mishan Road No. 5
2 Beijing CP District Beinong Road No. 2
dtype: object
这里虽然看起来有些繁杂,但是实际数据处理中对应的替换,一般都会通过代码来获取数据从而构造字典映射,在具体写法上会简洁的多。
8.3.5 提取
str.extract
进行提取:提取既可以认为是一种返回具体元素值(而不是布尔值或元素对应的索引位置)的匹配操作,也可以认为是一种特殊的拆分操作。前面提到的str.split
例子中会把分隔符去除,这并不是用户想要的效果,这时候就可以用str.extract
进行提取:
s.str.split('[市区路]')
Out[43]:
0 [上海, 黄浦, 方浜中, 249号]
1 [上海, 宝山, 密山, 5号]
dtype: objectpat = '(\w+市)(\w+区)(\w+路)(\d+号)'
s.str.extract(pat)
Out[78]:0 1 2 3
0 上海市 黄浦区 方浜中路 249号
1 上海市 宝山区 密山路 5号
2 北京市 昌平区 北农路 2号
通过子组的命名,可以直接对新生成DataFrame
的列命名:
pat = '(?P<市名>\w+市)(?P<区名>\w+区)(?P<路名>\w+路)(?P<编号>\d+号)'
s.str.extract(pat)
Out[79]: 市名 区名 路名 编号
0 上海市 黄浦区 方浜中路 249号
1 上海市 宝山区 密山路 5号
2 北京市 昌平区 北农路 2号
str.extractall
:不同于str.extract
只匹配一次,它会把所有符合条件的模式全部匹配出来,如果存在多个结果,则以多级索引的方式存储:
s = pd.Series(['A135T15,A26S5','B674S2,B25T6'], index = ['my_A','my_B'])
pat = '[A|B](\d+)[T|S](\d+)'
s.str.extractall(pat)
Out[83]:0 1match
my_A 0 135 151 26 5
my_B 0 674 21 25 6
pat_with_name = '[A|B](?P<name1>\d+)[T|S](?P<name2>\d+)'
s.str.extractall(pat_with_name)
Out[84]: name1 name2match
my_A 0 135 151 26 5
my_B 0 674 21 25 6
str.findall
:功能类似于str.extractall
,区别在于前者把结果存入列表中,而后者处理为多级索引,每个行只对应一组匹配,而不是把所有匹配组合构成列表。
s.str.findall(pat)
my_A [(135, 15), (26, 5)]
my_B [(674, 2), (25, 6)]
dtype: object
8.4、常用字符串函数
除了上述介绍的五类字符串操作有关的函数之外,str
对象上还定义了一些实用的其他方法,在此进行介绍。
8.4.1 字母型函数
upper, lower, title, capitalize, swapcase
这五个函数主要用于字母的大小写转化,从下面的例子中就容易领会其功能:
s = pd.Series(['lower', 'CAPITALS', 'this is a sentence', 'SwApCaSe'])s.str.upper()
Out[87]:
0 LOWER
1 CAPITALS
2 THIS IS A SENTENCE
3 SWAPCASE
dtype: objects.str.lower()
Out[88]:
0 lower
1 capitals
2 this is a sentence
3 swapcase
dtype: objects.str.title() # 首字母大写
Out[89]:
0 Lower
1 Capitals
2 This Is A Sentence
3 Swapcase
dtype: objects.str.capitalize() # 句首大写
Out[90]:
0 Lower
1 Capitals
2 This is a sentence
3 Swapcase
dtype: objects.str.swapcase() # 将大写转换为小写,将小写转换为大写。
Out[91]:
0 LOWER
1 capitals
2 THIS IS A SENTENCE
3 sWaPcAsE
dtype: objects.str.casefold() # 去除字符串中所有大小写区别0 lower
1 capitals
2 this is a sentence
3 swapcase
8.4.2 数值型函数
这里着重需要介绍的是pd.to_numeric
方法,它虽然不是str
对象上的方法,但是能够对字符格式的数值进行快速转换和筛选。其主要参数包括:
errors
:非数值的处理模式。对于不能转换为数值的有三种errors
选项:raise
:直接报错,默认选项coerce
:设为缺失值ignore
:保持原来的字符串。
downcast
:转换类型,转成 ‘integer’, ‘signed’, ‘unsigned’, 或 ‘float’的最小dtype。比如可以转成float32就不会转成float64。
s = pd.Series(['1', '2.2', '2e', '??', '-2.1', '0'])pd.to_numeric(s, errors='ignore')
Out[93]:
0 1
1 2.2
2 2e
3 ??
4 -2.1
5 0
dtype: objectpd.to_numeric(s, errors='coerce')
Out[94]:
0 1.0
1 2.2
2 NaN
3 NaN
4 -2.1
5 0.0
dtype: float64
在数据清洗时,可以利用coerce
的设定,快速查看非数值型的行:
s[pd.to_numeric(s, errors='coerce').isna()]
Out[95]:
2 2e
3 ??
dtype: object
8.4.3 统计型函数
count
和len
的作用分别是返回出现正则模式的次数和字符串的长度:
s = pd.Series(['cat rat fat at', 'get feed sheet heat'])s.str.count('[r|f]at|ee') # |左右两种子串都匹配了两次
Out[97]:
0 2
1 2
dtype: int64s.str.len()
Out[98]:
0 14
1 19
dtype: int64
8.4.4 格式型函数
格式型函数主要分为两类,第一种是除空型,第二种是填充型。其中,第一类函数一共有三种,它们分别是strip, rstrip, lstrip
,分别代表去除两侧空格、右侧空格和左侧空格。这些函数在数据清洗时是有用的,特别是列名含有非法空格的时候。
my_index = pd.Index([' col1', 'col2 ', ' col3 '])my_index.str.strip().str.len()
Out[100]: Int64Index([4, 4, 4], dtype='int64')my_index.str.rstrip().str.len()
Out[101]: Int64Index([5, 4, 5], dtype='int64')my_index.str.lstrip().str.len()
Out[102]: Int64Index([4, 5, 5], dtype='int64')
对于填充型函数而言,pad
是最灵活的,它可以选定字符串长度、填充的方向和填充内容:
s = pd.Series(['a','b','c'])s.str.pad(5,'left','*')
Out[104]:
0 ****a
1 ****b
2 ****c
dtype: objects.str.pad(5,'right','*')
Out[105]:
0 a****
1 b****
2 c****
dtype: objects.str.pad(5,'both','*')
Out[106]:
0 **a**
1 **b**
2 **c**
dtype: object
上述的三种情况可以分别用rjust, ljust, center
来等效完成,需要注意ljust
是指右侧填充而不是左侧填充:
s.str.rjust(5, '*')
Out[107]:
0 ****a
1 ****b
2 ****c
dtype: objects.str.ljust(5, '*')
Out[108]:
0 a****
1 b****
2 c****
dtype: objects.str.center(5, '*')
Out[109]:
0 **a**
1 **b**
2 **c**
dtype: object
在读取excel
文件时,经常会出现数字前补0的需求,例如证券代码读入的时候会把"000007"作为数值7来处理,pandas
中除了可以使用上面的左侧填充函数进行操作之外,还可用zfill
来实现。
s = pd.Series([7, 155, 303000]).astype('string')s.str.pad(6,'left','0')
Out[111]:
0 000007
1 000155
2 303000
dtype: strings.str.rjust(6,'0')
Out[112]:
0 000007
1 000155
2 303000
dtype: strings.str.zfill(6)
Out[113]:
0 000007
1 000155
2 303000
dtype: string
8.5 练习
Ex1:房屋信息数据集
现有一份房屋信息数据集如下:
df = pd.read_excel('../data/house_info.xls', usecols=['floor','year','area','price'])
df.head(3)
Out[115]: floor year area price
0 高层(共6层) 1986年建 58.23㎡ 155万
1 中层(共20层) 2020年建 88㎡ 155万
2 低层(共28层) 2010年建 89.33㎡ 365万
- 将year列改为整数年份存储。
- 将floor列替换为Level, Highest两列,其中的元素分别为string类型的层类别(高层、中层、低层)与整数类型的最高层数。
- 计算房屋每平米的均价avg_price,以***元/平米的格式存储到表中,其中***为整数
- 将
year
列改为整数年份存储。
"""
整个序列需要先转成Nullable类型的String类型,取出年份,再将年份转为Int64类型。
注意,转换的类型是Int64不是int,否则报错。即使astype加参数errors='ignore'跳过缺失值,
转成int后,序列还有缺失值所以,还是变成了object。
而整个序列转为Int,就还是Int类型,缺失值变成了 pd.NA 。
"""
df = df.convert_dtypes()
df['year']=df['year'].str.replace('\D','',regex=True).astype('Int64')
df.loc[df.year.notna()]['year'].head()0 1986
1 2020
2 2010
3 2014
4 2015
Name: year, Length: 12850, dtype: Int64
参考答案:
不知道为啥
pd.to_numeric(df.year.str[:-2],downcast="integer")
类型为float32,不应该是整型么
df.year = pd.to_numeric(df.year.str[:-2]).astype('Int64')
df.loc[df.year.notna()]['year']
- 将
floor
列替换为Level, Highest
两列,其中的元素分别为string
类型的层类别(高层、中层、低层)与整数类型的最高层数。
pat = '(?P<Level>\w+层)(?P<Highest>\(\w+层)'
df2=df['floor'].str.extract(pat) # 拆分成两列,第二列还是(共6层得形式,所以还的替换一次
df=pd.concat([df,df2],axis=1).convert_dtypes() # 新增列拼接在后面,再次转为Nullable类型
df['Highest']=df['Highest'].str.replace('\D+','',regex=True).astype('Int64')
df=df[['Level','Highest','year','area','price']]
df.head()Level Highest year area price
0 高层 6 1986 58.23㎡ 155万
1 中层 20 2020 88㎡ 155万
2 低层 28 2010 89.33㎡ 365万
3 低层 20 2014 82㎡ 308万
4 高层 1 2015 98㎡ 117万
# 参考答案。感觉是第二个字段加了中文的()可以准备匹配出数字,但是不好直接命令子组了
pat = '(\w层)(共(\d+)层)'
new_cols = df.floor.str.extract(pat).rename(columns={0:'Level', 1:'Highest'})df = pd.concat([df.drop(columns=['floor']), new_cols], 1)
df.head(3)Out[163]: year area price Level Highest
0 1986 58.23㎡ 155万 高层 6
1 2020 88㎡ 155万 中层 20
2 2010 89.33㎡ 365万 低层 28
- 计算房屋每平米的均价
avg_price
,以***元/平米
的格式存储到表中,其中***
为整数。
"""
str.findall返回的结果都是列表,只能用apply取值去掉列表形式
参考答案用pd.to_numeric(df.area.str[:-1])更简洁
由于area和price都没有缺失值,所以可以直接转类型
"""
df['new_area']=df['area'].str.findall(r'\d+.\d+|\d+').apply(lambda x:float(x[0]))
df['new_price']=df['price'].str.replace('\D+','',regex=True).astype('int64')
df.eval('avg_price=10000*new_price/new_area',inplace=True)
# 最后均价这一列小数转整型直接用.astype('int')就行,我还准备.apply(lambda x:int(round(x,0)))
# 最后数字+元/平米写法更简单
df['avg_price']=df['avg_price'].astype('int').astype('string')+'元/平米'
del df['new_area'],df['new_price']
df.head()Level Highest year area price avg_price
0 高层 6 1986 58.23㎡ 155万 26618元/平米
1 中层 20 2020 88㎡ 155万 17613元/平米
2 低层 28 2010 89.33㎡ 365万 40859元/平米
3 低层 20 2014 82㎡ 308万 37560元/平米
4 高层 1 2015 98㎡ 117万 11938元/平米
# 参考答案
s_area = pd.to_numeric(df.area.str[:-1])
s_price = pd.to_numeric(df.price.str[:-1])
df['avg_price'] = ((s_price/s_area)*10000).astype('int').astype('string') + '元/平米'df.head(3)
Out[167]: year area price Level Highest avg_price
0 1986 58.23㎡ 155万 高层 6 26618元/平米
1 2020 88㎡ 155万 中层 20 17613元/平米
2 2010 89.33㎡ 365万 低层 28 40859元/平米
Ex2:《权力的游戏》剧本数据集
现有一份权力的游戏剧本数据集如下:
df = pd.read_csv('../data/script.csv')
df.head(3)Out[115]:
Out[117]: Release Date Season Episode Episode Title Name Sentence
0 2011-04-17 Season 1 Episode 1 Winter is Coming waymar royce What do you expect? They're savages. One lot s...
1 2011-04-17 Season 1 Episode 1 Winter is Coming will I've never seen wildlings do a thing like this...
2 2011-04-17 Season 1 Episode 1 Winter is Coming waymar royce
- 计算每一个Episode的台词条数。
- 以空格为单词的分割符号,请求出单句台词平均单词量最多的前五个人。
- 若某人的台词中含有问号,那么下一个说台词的人即为回答者。若上一人台词中含有
datawhale8月组队学习《pandas数据处理与分析》(下)(文本、分类、时序数据)相关推荐
- datawhale6月组队学习-task01
datawhale6月组队学习-task01 1.数据加载 利用kaggle网站的泰坦尼克号数据集进行学习分析 下载网址: https://www.kaggle.com/c/titanic/overv ...
- Datawhale2021年11月组队学习——绪论与深度学习概述数学基础
以下内容为对Datawhale2021年11月组队学习中"水很深的深度学习"课程的绪论与深度学习概述以及数学基础的简要总结,其中小部分内容参考了网上一些资料. 原文链接: http ...
- Data Whale第20期组队学习 Pandas学习—缺失数据
Data Whale第20期组队学习 Pandas学习-缺失数据 一.缺失值的统计和删除 1.1 统计缺失信息 1.2 删除缺失信息 二.缺失值的填充和插值 2.1 利用fillna进行填充 2.2 ...
- Data Whale第20期组队学习 Pandas学习—时序数据
Data Whale第20期组队学习 Pandas学习-时序数据 一.时序中的基本对象 二.时间戳 2.1 Timestamp的构造与属性 2.2 Datetime序列的生成 2.3 dt对象 2.4 ...
- Data Whale第20期组队学习 Pandas学习—第一次综合练习
Data Whale第20期组队学习 Pandas学习-Task Special & 综合练习 一.企业收入的多样性 二.组队学习信息表的变换 三.美国大选投票情况 参考文献 一.企业收入的多 ...
- datawhale9月组队学习task01环境搭建,初始数据库
Datawhale9月组队学习 task01环境搭建,初始数据库 文章目录 Datawhale9月组队学习 task01环境搭建,初始数据库 一.环境搭建 1.MySQL 8.0的安装 2. 连接 M ...
- 你关注的房子降价了吗?Python分析下北京的二手房数据
前言 本文的文字及图片来源于网络,仅供学习.交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理. 作者:CDA数据分析师 对于许多在一线城市打拼的人群而言,能够在大城市安家 ...
- 【NLP】从整体视角了解情感分析、文本分类!
作者:太子长琴,算法工程师,Datawhale成员 文本分类是自然语言处理(NLP)最基础核心的任务,或者换句话说,几乎所有NLP任务都是「分类」任务,或者涉及到「分类」概念.比如分词.词性标注.命名 ...
- 从整体视角了解情感分析、文本分类!
NewBeeNLP干货 作者:太子长琴,算法工程师,Datawhale成员 文本分类是自然语言处理(NLP)最基础核心的任务,或者换句话说,几乎所有NLP任务都是「分类」任务,或者涉及到「分类」概念. ...
- Datawhale7月组队学习task1数据加载及探索性数据分析
Datawhale7月task1数据加载及探索性数据分析 有幸了解到了Datawhale这样一个开源组织,欣然报名了2021年7月的组队学习的动手学数据分析系列课程 本系列目标:完成kaggl ...
最新文章
- 打开My Lead detail page会发生timeout的错误的解决方案
- 化妆definer是什么意思_化妆品上的r是什么意思
- POJ3784-Running Median(运行中位数)【链表】
- Unicode和Ascii转byte,Unicode占二个byte,Ascii占一个byte
- Android APK程序加密,防止被别人反编译
- Linux开发标准LSB简介:Linux Standard Base
- php hook 键盘,Windows C++ 键盘钩子
- java基础之输入语句
- 15-07-22 数据库--存储过程、触发器
- Highcharts基础教程(二):图表配置
- 网络安全之特洛伊木马的攻防战略(转)
- 2020-10-13携程招聘算法题
- bitcoin-NG的分析
- 【数据处理】之读取csv文件报错
- 【Winform】 Enum逆向解析
- 2018深信服java笔试题,深信服2018秋招编程题
- 京东云安装docker
- 基于阿里云的API简介
- 为什么深圳成指关注度远远小于上证指数?
- 百度Sugar BI 数据可视化里的标签页组件如何实现
热门文章
- datawhale6月组队学习-task01