pandas-task08-文本数据.md

最新推荐文章于 2023-09-05 17:30:00 发布

Alex好好干饭

最新推荐文章于 2023-09-05 17:30:00 发布

阅读量352

点赞数 2

分类专栏： pandas 文章标签： python 正则表达式字符串

本文链接：https://blog.csdn.net/weixin_37734833/article/details/112276054

版权

pandas 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、str对象

1. str对象的设计意图

str 对象是定义在 Index 或 Series 上的属性，专门用于逐元素处理文本内容。在 pandas 的50个 str 对象方法中，有31个是和标准库中的 str 模块方法同名且功能一致，这为批量处理序列提供了有力的工具。

var = 'abcd'
str.upper(var) # 'ABCD'

s = pd.Series(['abcd', 'efg', 'hi'])
s.str.upper()

	0
0	ABCD
1	EFG
2	HI

2. []索引器

对于 str 对象而言，可理解为其对字符串进行了序列化的操作，例如在一般的字符串中，通过 [] 可以取出某个位置的元素：

var[0]
#  'a'

同时也能通过切片得到子串：

var[-1:0:-2]
#  'db'

通过对 str 对象使用 [] 索引器，可以完成完全一致的功能，并且如果超出范围则返回缺失值(这我没想到)：

s.str[0]
# 0    a
# 1    e
# 2    h
# dtype: object

s.str[-1: 0: -2]
# 0    db
# 1     g
# 2     i
# dtype: object

s.str[2]
# 0      c
# 1      g
# 2    NaN
# dtype: object

3. string类型

在上一章提到，从 pandas 的 1.0.0 版本开始，引入了 string 类型，其引入的动机在于：原来所有的字符串类型都会以 object 类型的 Series 进行存储，但 object 类型只应当存储混合类型，例如同时存储浮点、字符串、字典、列表、自定义类型等，因此字符串有必要同数值型或 category 一样，具有自己的数据存放类型，从而引入了 string 类型。

总体上说，绝大多数对于 object 和 string 类型的序列使用 str 对象方法产生的结果是一致，但是在下面提到的两点上有较大差异：

首先，应当尽量保证每一个序列中的值都是字符串的情况下才使用 str 属性，但这并不是必须的，其必要条件是序列中至少有一个可迭代（Iterable）对象，包括但不限于字符串、字典、列表。对于一个可迭代对象， string 类型的 str 对象和 object 类型的 str 对象返回结果可能是不同的。

s = pd.Series([{1: 'temp_1', 2: 'temp_2'}, 
			['a', 'b'], 0.5, 'my_string'])
s.str[1]
# 0    temp_1
# 1         b
# 2       NaN
# 3         y
# dtype: object

s.astype(np.str).str[1]
# 0    1
# 1    '
# 2    .
# 3    y
# dtype: object

这里我原来使用s.astype(‘string’)会报错，按理说升级了pandas到1.1.0应该就可以，原因未知。身边小伙伴有的正常有的和我一样，类型修改成np.str可以正常使用。

除了最后一个字符串元素，前几个元素返回的值都不同，其原因在于当序列类型为 object 时，是对于每一个元素进行 [] 索引，因此对于字典而言，返回temp_1字符串，对于列表则返回第二个值，而不可迭代对象，返回缺失值，最后一个是对字符串进行 [] 索引。而 string 类型的 str 对象先把整个元素转为字面意义的字符串，例如对于列表而言，第一个元素即 “{“，而对于最后一个字符串元素而言，恰好转化前后的表示方法一致，因此结果和 object 类型一致。

除了对于某些对象的 str 序列化方法不同之外，两者另外的一个差别在于， 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()
# 0    1
# dtype: int64

s.astype('string').str.len() 
# 0    1
# dtype: Int64

s == 'a' 
# 0    True
# dtype: bool

s.astype('string') == 'a' 
# 0    True
# dtype: boolean

s = pd.Series(['a', np.nan]) # 带有缺失值
s.str.len()
# 0    1.0
# 1    NaN
# dtype: float64

s.astype('string').str.len()
# 0       1
# 1    <NA>
# dtype: Int64

s == 'a'
# 0     True
# 1    False
# dtype: bool

s.astype('string') == 'a'
# 0    True
# 1    <NA>
# dtype: boolean

最后需要注意的是，对于全体元素为数值类型的序列，即使其类型为 object 或者 category 也不允许直接使用 str 属性。如果需要把数字当成 string 类型处理，可以使用 astype 强制转换为 string 类型的 Series ：

s = pd.Series([12, 345, 6789])

s.astype('string').str[1]
# 0    2
# 1    4
# 2    7
# dtype: string

二、正则表达式基础

1. 一般字符的匹配

正则表达式是一种按照某种正则模式，从左到右匹配字符串中内容的一种工具。对于一般的字符而言，它可以找到其所在的位置，这里为了演示便利，使用了 python 中 re 模块的 findall 函数来匹配所有出现过但不重叠的模式，第一个参数是正则表达式，第二个参数是待匹配的字符串。例如，在下面的字符串中找出 apple ：

import re
re.findall('apple','one apple a day,
			keep doctor away!Apple,apple!')
# ['apple', 'apple']

这里对大小写敏感，找到所有一致的字符串。

2. 元字符基础

在这里插入图片描述
代码练习

re.findall(r'.', 'abc')# 匹配任意字符
# [a,b,c]

re.findall(r'[ac]', 'abc')# 匹配a、c字符
#['a', 'c']

re.findall(r'[^b]{2}', 'aaaabbbbacccccccba')
# 匹配除b以外的其他字符 该示例中即a、c，要求匹配长度为2，即可能的组合为aa、ac、ca、cc,从左往右依次匹配，匹配到的就不再看了 所以依次匹配到aa aa ac cc cc cc
# ['aa', 'aa', 'ac', 'cc', 'cc', 'cc'] 

re.findall(r'[^b]{2,3}', 'aaaabbbbacccccccba')
# 类似上面 但是匹配长度区间为[2,3] 组合种类更多
# ['aaa', 'acc', 'ccc', 'cc']

re.findall(r'aaa|bbb','aaaabbbb')# 匹配aaa 或者 bbb
# ['aaa', 'bbb']

re.findall(r'a\\?|a\*', 'aa?a*a')
#\表示转义，\\即代表真正的“\”符号 
# ?表示0次或1次，故\\?表示0次或1次“\”
# 结合起来 |左边即代表 a或者 a\
# 所以整个表达式含义为 从左往右依次匹配字符串中 a 或 a\ 或a*
# 每次匹配到a 就继续往后匹配 所以没有机会匹配到其他符号
# ['a', 'a', 'a', 'a'] 

re.findall(r'a?.', 'abaacadaae')
# 匹配 0个a或1个a  和其他任意一个字符
# ['ab', 'aa', 'c', 'ad', 'aa', 'e']

3. 简写字符集

此外，正则表达式中还有一类简写字符集，其等价于一组字符的集合：
在这里插入图片描述

re.findall(r'.s', 'Apple! This Is an Apple!')
# ['is', 'Is']

re.findall(r'\w{2}', '09 8? 7w c_ 9q p@')
# 匹配长度为2的字母、数字、下划线
# ['09', '7w', 'c_', '9q']

re.findall(r'\w\W\B','09 8? 7w c_ 9q p@')
# ['8?', 'p@']

re.findall(r'.\s.','Constant dropping wears the stone.')
# 匹配中间空格 长度为3的字符
# Out[40]: ['t d', 'g w', 's t', 'e s']

re.findall(r'上海市(.{2}区)(.{2,3}路)(\d+号)','上海市黄浦区方浜中路249号 上海市宝山区密山路5号')
#  [('黄浦区', '方浜中路', '249号'), ('宝山区', '密山路', '5号')]

三、文本处理的五类操作

1. 拆分

str.split 能够把字符串的列进行拆分，其中第一个参数为正则表达式，可选参数包括从左到右的最大拆分次数 n ，是否展开为多个列 expand 。和python几乎一致。

s = pd.Series(['上海市黄浦区方浜中路249号',
                '上海市宝山区密山路5号'])
s.str.split('[市区路]')
# 0    [上海, 黄浦, 方浜中, 249号]
# 1       [上海, 宝山, 密山, 5号]
# dtype: object

s.str.split(r'(.{2}区)(.{2,3}路)(\d+号)')
# 0    [上海市, 黄浦区, 方浜中路, 249号, ]
# 1       [上海市, 宝山区, 密山路, 5号, ]
# dtype: object

s.str.split('[市区路]',n=2, expand=True)
# 不设置expend时
# 0    [上海, 黄浦, 方浜中, 249号]
# 1       [上海, 宝山, 密山, 5号]
# dtype: object

设置了expend后，展开为多个列

	0	1	2
0	上海	黄浦	方浜中路249号
1	上海	宝山	密山路5号

最大拆分次数为n,拆一次会分裂成两部分，所以拆分后为n+1部分。
试下n=3

s.str.split('[市区路]',n=3, expand=True)

	0	1	2	3
0	上海	黄浦	方浜中	249号
1	上海	宝山	密山	5号

2. 合并

join 和 cat
区别在于join是内部的，比如将一个Series中字符串列表通过‘-’符号连接起来，而cat是外部的，如两个Series相连接。

s = pd.Series([['a','b'], [1, 'a'], [['a', 'b'], 'c']])

s.str.join('-')
# 0    a-b
# 1    NaN
# 2    NaN
# dtype: object

对于非字符型连接会变成NaN,试一下连接前将类型转成string。

s = pd.Series([['a','b'], [1, 'a'], [['a', 'b'], 'c']])
s.astype(np.str).str.join('-')
# 0                  [-'-a-'-,- -'-b-'-]
# 1                      [-1-,- -'-a-'-]
# 2    [-[-'-a-'-,- -'-b-'-]-,- -'-c-'-]
# dtype: object

str.cat 用于合并两个序列，主要参数为连接符 sep 、连接形式 join 以及缺失值替代符号 na_rep ，其中连接形式默认为以索引为键的左连接。

s1 = pd.Series(['a','b'])
s2 = pd.Series(['cat','dog'])
s2.index = [1, 2]
s1.str.cat(s2,sep='-',na_rep='?',join='outer')
# 0      a-?
# 1    b-cat
# 2    ?-dog
# dtype: object

3. 匹配

str.contains 返回了每个字符串是否包含正则模式的布尔序列：

s = pd.Series(['my cat', 'he is fat', 'railway station'])

s.str.contains('\s\wat')# 是否包含空格+字母/数字/下划线+at的字符
# 0     True
# 1     True
# 2    False
# dtype: bool

str.startswith 和 str.endswith 返回了每个字符串以给定模式为开始和结束的布尔序列，它们都不支持正则表达式：

s = pd.Series(['my cat', 'he is fat', 'railway station'])
s.str.startswith('my')
# 0     True
# 1    False
# 2    False
# dtype: bool

如果需要用正则表达式来检测开始或结束字符串的模式，可以使用 str.match ，其返回了每个字符串起始处是否符合给定正则模式的布尔序列：

s.str[::-1].str.match('tac')
# 反转后匹配是否有tac开始的字符串
# 反转后
# 0             tac ym
# 1          taf si eh
# 2    noitats yawliar
# dtype: object

# 匹配结果
# 0     True
# 1    False
# 2    False
# dtype: bool

当然，这些也能通过在 str.contains 的正则中使用 ^ 和 $ 来实现：

s.str.contains(r'[f|c]at$')
# 匹配结尾是否有fat或cat

# 0     True
# 1     True
# 2    False
# dtype: bool

除了上述返回值为布尔的匹配之外，还有一种返回索引的匹配函数，即 str.find 与 str.rfind ，其分别返回从左到右和从右到左第一次匹配的位置的索引，未找到则返回-1。需要注意的是这两个函数不支持正则匹配，只能用于字符子串的匹配：

s.str[::-1].str.find('ym')
# 0    4
# 1   -1
# 2   -1
# dtype: int64

4. 替换

str.replace 和 replace 并不是一个函数，在使用字符串替换时应当使用前者。

s = pd.Series(['a_1_b','c_?'])#将数字或？替换成"new"

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+号)'
s.str.findall(r'(\w+市)(\w+区)(\w+路)(\d+号)')

先看下按照正则表达式匹配到的结果：

	0
0	[(‘上海市’, ‘黄浦区’, ‘方浜中路’, ‘249号’)]
1	[(‘上海市’, ‘宝山区’, ‘密山路’, ‘5号’)]
2	[(‘北京市’, ‘昌平区’, ‘北农路’, ‘2号’)]

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)

?P的意思就是命名一个名字为value的组，匹配规则符合后面的规则。

5. 提取

提取既可以认为是一种返回具体元素（而不是布尔值或元素对应的索引位置）的匹配操作，也可以认为是一种特殊的拆分操作。前面提到的 str.split 例子中会把分隔符去除，这并不是用户想要的效果，这时候就可以用 str.extract 进行提取：

In [76]: pat = '(\w+市)(\w+区)(\w+路)(\d+号)'

In [77]: s.str.extract(pat)
Out[77]: 
     0    1     2     3
0  上海市  黄浦区  方浜中路  249号
1  上海市  宝山区   密山路    5号
2  北京市  昌平区   北农路    2号

通过子组的命名，可以直接对新生成 DataFrame 的列命名：

In [78]: pat = '(?P<市名>\w+市)(?P<区名>\w+区)(?P<路名>\w+路)(?P<编号>\d+号)'

In [79]: s.str.extract(pat)
Out[79]: 
    市名   区名    路名    编号
0  上海市  黄浦区  方浜中路  249号
1  上海市  宝山区   密山路    5号
2  北京市  昌平区   北农路    2号

str.extractall 不同于 str.extract 只匹配一次，它会把所有符合条件的模式全部匹配出来，如果存在多个结果，则以多级索引的方式存储：

In [80]: s = pd.Series(['A135T15,A26S5','B674S2,B25T6'], index = ['my_A','my_B'])

In [81]: pat = '[A|B](\d+)[T|S](\d+)'

In [82]: s.str.extractall(pat)
Out[82]: 
              0   1
     match         
my_A 0      135  15
     1       26   5
my_B 0      674   2
     1       25   6

In [83]: pat_with_name = '[A|B](?P<name1>\d+)[T|S](?P<name2>\d+)'

In [84]: s.str.extractall(pat_with_name)
Out[84]: 
           name1 name2
     match            
my_A 0       135    15
     1        26     5
my_B 0       674     2
     1        25     6

str.findall 的功能类似于 str.extractall ，区别在于前者把结果存入列表中，而后者处理为多级索引，每个行只对应一组匹配，而不是把所有匹配组合构成列表。

In [85]: s.str.findall(pat)
Out[85]: 
my_A    [(135, 15), (26, 5)]
my_B     [(674, 2), (25, 6)]
dtype: object

四、常用字符串函数

除了上述介绍的五类字符串操作有关的函数之外， str 对象上还定义了一些实用的其他方法，在此进行介绍：

1. 字母型函数

upper, lower, title, capitalize, swapcase 这五个函数主要用于字母的大小写转化，从下面的例子中就容易领会其功能：

In [86]: s = pd.Series(['lower', 'CAPITALS', 'this is a sentence', 'SwApCaSe'])

In [87]: s.str.upper()# 大写
Out[87]: 
0                 LOWER
1              CAPITALS
2    THIS IS A SENTENCE
3              SWAPCASE
dtype: object

In [88]: s.str.lower()# 小写
Out[88]: 
0                 lower
1              capitals
2    this is a sentence
3              swapcase
dtype: object

In [89]: s.str.title()# 每个单词首字母大写
Out[89]: 
0                 Lower
1              Capitals
2    This Is A Sentence
3              Swapcase
dtype: object

In [90]: s.str.capitalize()#整句只有首个单词大写
Out[90]: 
0                 Lower
1              Capitals
2    This is a sentence
3              Swapcase
dtype: object

In [91]: s.str.swapcase()#转换大小写
Out[91]: 
0                 LOWER
1              capitals
2    THIS IS A SENTENCE
3              sWaPcAsE
dtype: object

2. 数值型函数

这里着重需要介绍的是 pd.to_numeric 方法，它虽然不是 str 对象上的方法，但是能够对字符格式的数值进行快速转换和筛选。其主要参数包括 errors 和 downcast 分别代表了非数值的处理模式和转换类型。其中，对于不能转换为数值的有三种 errors 选项， raise, coerce, ignore 分别表示直接报错、设为缺失以及保持原来的字符串。

In [92]: s = pd.Series(['1', '2.2', '2e', '??', '-2.1', '0'])

In [93]: pd.to_numeric(s, errors='ignore')
Out[93]: 
0       1
1     2.2
2      2e
3      ??
4    -2.1
5       0
dtype: object

In [94]: pd.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 的设定，快速查看非数值型的行：

In [95]: s[pd.to_numeric(s, errors='coerce').isna()]
Out[95]: 
2    2e
3    ??
dtype: object

3. 统计型函数

count 和 len 的作用分别是返回出现正则模式的次数和字符串的长度.

In [96]: s = pd.Series(['cat rat fat at', 'get feed sheet heat'])

In [97]: s.str.count('[r|f]at|ee')
Out[97]: 
0    2
1    2
dtype: int64

In [98]: s.str.len()
Out[98]: 
0    14
1    19
dtype: int64

4. 格式型函数

格式型函数主要分为两类，第一种是除空型，第二种时填充型。其中，第一类函数一共有三种，它们分别是 strip, rstrip, lstrip ，分别代表去除两侧空格、右侧空格和左侧空格。这些函数在数据清洗时是有用的，特别是列名含有非法空格的时候。

In [99]: my_index = pd.Index([' col1', 'col2 ', ' col3 '])

In [100]: my_index.str.strip().str.len()
Out[100]: Int64Index([4, 4, 4], dtype='int64')

In [101]: my_index.str.rstrip().str.len()
Out[101]: Int64Index([5, 4, 5], dtype='int64')

In [102]: my_index.str.lstrip().str.len()
Out[102]: Int64Index([4, 5, 5], dtype='int64')

对于填充型函数而言， pad 是最灵活的，它可以选定字符串长度、填充的方向和填充内容：

In [103]: s = pd.Series(['a','b','c'])

In [104]: s.str.pad(5,'left','*')
Out[104]: 
0    ****a
1    ****b
2    ****c
dtype: object

In [105]: s.str.pad(5,'right','*')
Out[105]: 
0    a****
1    b****
2    c****
dtype: object

In [106]: s.str.pad(5,'both','*')
Out[106]: 
0    **a**
1    **b**
2    **c**
dtype: object

上述的三种情况可以分别用 rjust, ljust, center 来等效完成，需要注意 ljust 是指右侧填充而不是左侧填充：

In [107]: s.str.rjust(5, '*')
Out[107]: 
0    ****a
1    ****b
2    ****c
dtype: object

In [108]: s.str.ljust(5, '*')
Out[108]: 
0    a****
1    b****
2    c****
dtype: object

In [109]: s.str.center(5, '*')
Out[109]: 
0    **a**
1    **b**
2    **c**
dtype: object

在读取 excel 文件时，经常会出现数字前补0的需求，例如证券代码读入的时候会把”000007”作为数值7来处理， pandas 中除了可以使用上面的左侧填充函数进行操作之外，还可用 zfill 来实现。

In [110]: s = pd.Series([7, 155, 303000]).astype('string')

In [111]: s.str.pad(6,'left','0')
Out[111]: 
0    000007
1    000155
2    303000
dtype: string

In [112]: s.str.rjust(6,'0')
Out[112]: 
0    000007
1    000155
2    303000
dtype: string

In [113]: s.str.zfill(6)
Out[113]: 
0    000007
1    000155
2    303000
dtype: string

五、练习

Ex1：房屋信息数据集

在这里插入图片描述

将 year 列改为整数年份存储

df['year']=df['year'].str.replace(r'年建','')
df.head()

	floor	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万

答案给的方法是使用pd.to_numeric 方法，它虽然不是 str 对象上的方法，但是能够对字符格式的数值进行快速转换，在这里使用更合理：

df.year = pd.to_numeric(df.year.str[:-2]).astype('Int64')

将 floor 列替换为 Level, Highest 两列，其中的元素分别为 string 类型的层类别（高层、中层、低层）与整数类型的最高层数。
首先利用正则表达式将floor中的等级和最高层找到，然后利用str.extract提取需要的列,使用正则表达式的时候可以直接命名组，后面就不用再对列重命名了。

pat='(?P<Level>\w层)（共(?P<Highest>\d+)层）'
df['floor'].str.extract(pat).head()

	Level	Highest
0	高层	6
1	中层	20
2	低层	28
3	低层	20
4	高层	1

之后再拼接上，以及把floor列去除即可，下面是完整代码：

pat='(?P<Level>\w层)（共(?P<Highest>\d+)层）'
floor_cols=df['floor'].str.extract(pat)
df=pd.concat([df,floor_cols],1).drop(columns=['floor'])
df

	year	area	price	Level	Highest
0	1986	58.23㎡	155万	高层	6
1	2020	88㎡	155万	中层	20
2	2010	89.33㎡	365万	低层	28
3	2014	82㎡	308万	低层	20
4	2015	98㎡	117万	高层	1

计算房屋每平米的均价 avg_price ，以 ***元/平米的格式存储到表中，其中 ***为整数。

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)

	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：《权力的游戏》剧本数据集

在这里插入图片描述

计算每一个 Episode 的台词条数。
刚开始我心想直接用个gropuby不就行了嘛，结果报列名错误。打印了下列名发现几个列前后都有空格。
[‘Release Date’, ’ Season’, 'Episode ', ‘Episode Title’, ‘Name’,
‘Sentence’]
先将列名空格空格去掉再做就ok了

df.columns = df.columns.str.strip()
df.groupby(['Season', 'Episode'])['Sentence'].count().head()

	Sentence
(‘Season 1’, ‘Episode 1’)	327
(‘Season 1’, ‘Episode 10’)	266
(‘Season 1’, ‘Episode 2’)	283
(‘Season 1’, ‘Episode 3’)	353
(‘Season 1’, ‘Episode 4’)	404

以空格为单词的分割符号，请求出单句台词平均单词量最多的前五个人。

df.set_index('Name').Sentence.str.split().str.len(
     ).groupby('Name').mean().sort_values(ascending=False).head()

Name	Sentence
male singer	109
slave owner	77
manderly	62
lollys stokeworth	62
dothraki matron	56.6667

这个单组做按空格分裂、分组求平均，求字符串长度都会，但是组合起来有点难度。

若某人的台词中含有问号，那么下一个说台词的人即为回答者。若上一人台词中含有 n 个问号，则认为回答者回答了 n 个问题，请求出回答最多问题的前五个人。

这个也是看了答案后有思路的。

s = pd.Series(df.Sentence.values, index=df.Name.shift(-1))
s.str.count('\?').groupby('Name').sum().sort_values(ascending=False).head()

Name	0
tyrion lannister	527
jon snow	374
jaime lannister	283
arya stark	265
cersei lannister	246

Alex好好干饭

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
3
评论
pandas-task08-文本数据.md

文章目录一、str对象1. str对象的设计意图2. []索引器3. string类型二、正则表达式基础1. 一般字符的匹配2. 元字符基础3. 简写字符集三、文本处理的五类操作1. 拆分2. 合并3. 匹配4. 替换5. 提取四、常用字符串函数1. 字母型函数2. 数值型函数3. 统计型函数4. 格式型函数五、练习Ex1：房屋信息数据集![在这里插入图片描述](https://img-blog.csdnimg.cn/2021010622052797.png?x-oss-process=image/wate
复制链接

扫一扫