Data Whale第20期组队学习 Pandas学习—文本数据
Pandas提供了一组字符串函数，可以方便地对字符串数据进行操作。 最重要的是，这些函数忽略(或排除)丢失/NaN值。
一、str对象
1.1 str对象的设计意图
str 对象是定义在 Index 或 Series 上的属性，专门用于逐元素处理文本内容，其内部定义了大量方法，因此对一个序列进行文本处理，首先需要获取其 str 对象。在Python标准库中也有 str 模块.
import pandas as pd
import numpy as np
res='hello world'
print("str.upper(res)=",str.upper(res))
# str.upper(res)= HELLO WORLD
Ser=pd.Series(['hello','world','China'])
print("Ser.str=",Ser.str)
# Ser.str= <pandas.core.strings.StringMethods object at 0x000001A0A4CFEFD0>
print("Ser.str.islower()=",Ser.str.islower())
# Ser.str.islower()= 0 True
# 1 True
# 2 False
# dtype: bool
1.2 []索引器
对于 str 对象而言，可理解为其对字符串进行了序列化的操作，例如在一般的字符串中，通过 [] 可以取出某个位置的元素.
print("res[2]=",res[2])
# res[2]= l
# 通过切片得到子串
print("res[-1:0:-4]=",res[-1:0:-4])
# res[-1:0:-4]= dwl
# 通过对 str 对象使用 [] 索引器，可以完成完全一致的功能，并且如果超出范围则返回缺失值
print("Ser.str[0]=",Ser.str[0])
# Ser.str[0]= 0 h
# 1 w
# 2 C
# dtype: object
print("Ser.str[-1:0:-2]=",Ser.str[-1:0:-2])
# Ser.str[-1:0:-2]= 0 ol
# 1 dr
# 2 ai
# dtype: object
print("Ser.str[3]=",Ser.str[3])
# Ser.str[3]= 0 l
# 1 l
# 2 n
# dtype: object
1.3 string类型
体上说，绝大多数对于 object 和 string 类型的序列使用 str 对象方法产生的结果是一致，但是在下面提到的两点上有较大差异：
首先，应当尽量保证每一个序列中的值都是字符串的情况下才使用 str 属性，但这并不是必须的，其必要条件是序列中至少有一个可迭代（Iterable）对象，包括但不限于字符串、字典、列表。对于一个可迭代对象， string 类型的 str 对象和 object 类型的 str 对象返回结果可能是不同的。
Ser1=pd.Series([{1: 'temp1', 2: 'temp2',3: 'temp3', 4: 'temp4'}, ['x', 'y','i','j'], 0.5, 'my_string'])
print("Ser1.str[2]=",Ser1.str[2])
# Ser1.str[2]= 0 temp2
# 1 i
# 2 NaN
# 3 _
# dtype: object
print("Ser.astype('string').str[2]=",Ser1.astype('string').str[2])
# Ser.astype('string').str[2]= 0 :
# 1 x
# 2 5
# 3 _
# dtype: string
除了最后一个字符串元素，前三个元素返回的值都不同，其原因在于当序列类型为 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 不会。
Ser2=pd.Series(['s','w','o',np.nan,1,2])
print("Ser2.str.len()=",Ser2.str.len())
# Ser2.str.len()= 0 1.0
# 1 1.0
# 2 1.0
# 3 NaN
# 4 NaN
# 5 NaN
# dtype: float64
print("Ser2.astype('string').str.len()=",Ser2.astype('string').str.len())
# Ser2.astype('string').str.len()= 0 1
# 1 1
# 2 1
# 3 <NA>
# 4 1
# 5 1
# dtype: Int64
print("Ser2.astype('string')=='h':",Ser2.astype('string')=='h')
# Ser2.astype('string')=='h': 0 False
# 1 False
# 2 False
# 3 <NA>
# 4 False
# 5 False
# dtype: boolean
格外注意的是，对于全体元素为数值类型的序列，即使其类型为 object 或者 category 也不允许直接使用 str 属性。如果需要把数字当成 string 类型处理，可以使用 astype 强制转换为 string 类型的 Series 。
ser = pd.Series([2020, 12, 24])
print("ser.astype('string').str[1]=",ser.astype('string').str[1])
# ser.astype('string').str[1]= 0 0
# 1 2
# 2 4
# dtype: string
二、正则表达式基础
2.1 一般字符的匹配
正则表达式是一种按照某种正则模式，从左到右匹配字符串中内容的一种工具。对于一般的字符而言，它可以找到其所在的位置，这里为了演示便利，使用了 python 中 re 模块的 findall 函数来匹配所有出现过但不重叠的模式，第一个参数是正则表达式，第二个参数是待匹配的字符串。
# 在下面的字符串中找出 apple
import re
print("re.findall('apple','apple! This Is an apple!')=",
re.findall('apple','apple! This Is an apple!'))
# re.findall('apple','apple! This Is an apple!')= ['apple', 'apple']
2.2 元字符基础
| 序号 | 元字符 | 描述 |
|---|---|---|
| 1 | . | 匹配除换行符以外的任意字符 |
| 2 | [ ] | 字符类，匹配方括号中包含的任意字符 |
| 3 | [^ ] | 否定字符类，匹配方括号中不包含的任意字符 |
| 4 | * | 匹配前面的子表达式零次或多次 |
| 5 | + | 匹配前面的子表达式一次或多次 |
| 6 | ？ | 匹配前面的子表达式零次或一次 |
| 8 | {n,m} | 花括号，匹配前面字符至少 n 次，但是不超过 m 次 |
| 9 | (xyz) | 字符组，按照确切的顺序匹配字符xyz |
| 10 | ||
| 11 | \ | 转义符，它可以还原元字符原来的含义 |
| 12 | ^ | 匹配行的开始 |
| 13 | $ | 匹配行的结束 |
print("re.findall('.', 'abcdefgh')=",re.findall('.', 'abcdefgh'))
# re.findall('.', 'abcdefgh')= ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
print("re.findall('[ac]', 'abccbaabc')=",re.findall('[ac]', 'abccbaabc'))
# re.findall('[ac]', 'abccbaabc')= ['a', 'c', 'c', 'a', 'a', 'c']
print("re.findall('[^ac]', 'abcbbbdd')=",re.findall('[^ac]', 'abcbbbdd'))
# re.findall('[^ac]', 'abcbbbdd')= ['b', 'b', 'b', 'b', 'd', 'd']
print("re.findall('[ab]{2}', 'aaaabbbb')=",re.findall('[ab]{2}', 'aaaabbbb'))
# re.findall('[ab]{2}', 'aaaabbbb')= ['aa', 'aa', 'bb', 'bb']
print("re.findall('aaa|bbb', 'aaaabbbb')=", re.findall('aaa|bbb', 'aaaabbbb'))
# re.findall('aaa|bbb', 'aaaabbbb')= ['aaa', 'bbb']
print("re.findall('a\\?|a\*', 'aa?a*a')=",re.findall('a\\?|a\*', 'aa?a*a'))
# re.findall('a\?|a\*', 'aa?a*a')= ['a?', 'a*']
print("re.findall('a?.', 'abaacadaae')=",re.findall('a?.', 'abaacadaae'))
# re.findall('a?.', 'abaacadaae')= ['ab', 'aa', 'c', 'ad', 'aa', 'e']
2.3 简写字符集
正则表达式中还有一类简写字符集，其等价于一组字符的集合
| 序号 | 简写 | 描述 |
|---|---|---|
| 1 | \w | 匹配所有字母、数字、下划线: [a-zA-Z0-9_] |
| 2 | \W | 匹配非字母和数字的字符: [^\w] |
| 3 | \d | 匹配数字: [0-9] |
| 4 | \D | 匹配非数字: [^\d] |
| 5 | \s | 匹配空格符: [\t\n\f\r\p{Z}] |
| 6 | \S | 匹配非空格符: [^\s] |
| 7 | \B | 匹配一组非空字符开头或结尾的位置，不代表具体字符 |
print("re.findall('.s', 'Apple! This Is an Apple!')=",re.findall('.s', 'Apple! This Is an Apple!'))
# re.findall('.s', 'Apple! This Is an Apple!')= ['is', 'Is']
print("re.findall('\w{2}', '09 8? 7w c_ 9q p@')=",re.findall('\w{2}', '09 8? 7w c_ 9q p@'))
# re.findall('\w{2}', '09 8? 7w c_ 9q p@')= ['09', '7w', 'c_', '9q']
print("re.findall('\w\W\B', '09 8? 7w c_ 9q p@')=",re.findall('\w\W\B', '09 8? 7w c_ 9q p@'))
# re.findall('\w\W\B', '09 8? 7w c_ 9q p@')= ['8?', 'p@']
print("re.findall('.\s.', 'Constant dropping wears the stone.')=",
re.findall('.\s.', 'Constant dropping wears the stone.'))
# re.findall('.\s.', 'Constant dropping wears the stone.')= ['t d', 'g w', 's t', 'e s']
print("re.findall('北京市(.{2,3}区)(.{2,3}路)(\d+号)','北京市海淀区方浜中路249号 北京市昌平区密山路5号')=",
re.findall('北京市(.{2,3}区)(.{2,3}路)(\d+号)','北京市海淀区方浜中路249号 北京市昌平区密山路5号'))
# re.findall('北京市(.{2,3}区)(.{2,3}路)(\d+号)','北京市海淀区方浜中路249号 北京市昌平区密山路5号')= [('海淀区', '方浜中路', '249号'), ('昌平区', '密山路', '5号')]
三、文本处理的五类操作
3.1 拆分
str.split 能够把字符串的列进行拆分，其中第一个参数为正则表达式，可选参数包括从左到右的最大拆分次数 n ，是否展开为多个列 expand 。
Ser3 = pd.Series(['上海市黄浦区方浜中路249号','上海市宝山区密山路5号'])
print("Ser3.str.split('[市区路]')=",Ser3.str.split('[市区路]'))
# Ser3.str.split('[市区路]')= 0 [上海, 黄浦, 方浜中, 249号]
# 1 [上海, 宝山, 密山, 5号]
# dtype: object
print("Ser3.str.split('[市区路]', n=2, expand=True)=",Ser3.str.split('[市区路]', n=2, expand=True))
# Ser3.str.split('[市区路]', n=2, expand=True)= 0 1 2
# 0 上海 黄浦 方浜中路249号
# 1 上海 宝山 密山路5号
与其类似的函数是 str.rsplit ，其区别在于使用 n 参数的时候是从右到左限制最大拆分次数
print("Ser3.str.rsplit('[市区路]', n=2, expand=True)=",Ser3.str.rsplit('[市区路]', n=2, expand=True))
# Ser3.str.rsplit('[市区路]', n=2, expand=True)= 0
# 0 上海市黄浦区方浜中路249号
# 1 上海市宝山区密山路5号
3.2 合并
合并一共有两个函数，分别是 str.join 和 str.cat 。 str.join 表示用某个连接符把 Series 中的字符串列表连接起来，如果列表中出现了字符串元素则返回缺失值.
str.cat 用于合并两个序列，主要参数为连接符 sep 、连接形式 join 以及缺失值替代符号 na_rep ，其中连接形式默认为以索引为键的左连接。
Ser4 = pd.Series([['a','b','d'], [1, 'a','p'], [['a', 'b','w'], 'c','w']])
print("Ser4.str.join('-')=",Ser4.str.join('-'))
# Ser4.str.join('-')= 0 a-b-d
# 1 NaN
# 2 NaN
# dtype: object
S1=pd.Series(['c','d'])
S2=pd.Series(['cat','dog'])
print("S1.str.cat(S2,sep='-')=",S1.str.cat(S2,sep='-'))
# S1.str.cat(S2,sep='-')= 0 c-cat
# 1 d-dog
# dtype: object
S2.index = [1, 2]
print("S1.str.cat(S2, sep='-', na_rep='?', join='outer')=",
S1.str.cat(S2, sep='-', na_rep='?', join='outer'))
# S1.str.cat(S2, sep='-', na_rep='?', join='outer')= 0 c-?
# 1 d-cat
# 2 ?-dog
# dtype: object
3.3 匹配
str.contains 返回了每个字符串是否包含正则模式的布尔序列,str.startswith 和 str.endswith 返回了每个字符串以给定模式为开始和结束的布尔序列，它们都不支持正则表达式.如果需要用正则表达式来检测开始或结束字符串的模式，可以使用 str.match ，其返回了每个字符串起始处是否符合给定正则模式的布尔序列
S3 = pd.Series(['my cat', 'he is fat', 'railway station'])
print("S3.str.contains('\s\wat')=",S3.str.contains('\s\wat'))
# S3.str.contains('\s\wat')= 0 True
# 1 True
# 2 False
# dtype: bool
print("S3.str.startswith('my')=",S3.str.startswith('my'))
# S3.str.startswith('my')= 0 True
# 1 False
# 2 False
# dtype: bool
print("S3.str.endswith('t')=",S3.str.endswith('t'))
# S3.str.endswith('t')= 0 True
# 1 True
# 2 False
# dtype: bool
print("S3.str.match('m|h')=",S3.str.match('m|h'))
# S3.str.match('m|h')= 0 True
# 1 True
# 2 False
# dtype: bool
print("S3.str[::-1].str.match('ta[f|g]|n')",S3.str[::-1].str.match('ta[f|g]|n'))
# S3.str[::-1].str.match('ta[f|g]|n') 0 False
# 1 True
# 2 True
# dtype: bool
print("S3.str.contains('^[m|h]')=",S3.str.contains('^[m|h]'))
# S3.str.contains('^[m|h]')= 0 True
# 1 True
# 2 False
# dtype: bool
print("S3.str.contains('[f|g]at|n$')=", S3.str.contains('[f|g]at|n$'))
# S3.str.contains('[f|g]at|n$')= 0 False
# 1 True
# 2 True
# dtype: bool
3.4 替换
str.replace 和 replace 并不是一个函数，在使用字符串替换时应当使用前者。当需要对不同部分进行有差别的替换时，可以利用 子组 的方法，并且此时可以通过传入自定义的替换函数来分别进行处理，注意 group(k) 代表匹配到的第 k 个子组（圆括号之间的内容）
S4=pd.Series(['a_1_b_d_f','c_?_p_o_?_l'])
print("S4.str.replace('\d|\?', 'good')=",S4.str.replace('\d|\?', 'good'))
# S4.str.replace('\d|\?', 'good')= 0 a_good_b_d_f
# 1 c_good_p_o_good_l
# dtype: object
"""
当需要对不同部分进行有差别的替换时，可以利用 子组 的方法，并且此时可以通过
传入自定义的替换函数来分别进行处理，注意 group(k) 代表匹配到的第 k 个子组（圆括号之间的内容）
"""
S5=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_function(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])
print("S5.str.replace(pat, my_function)=",S5.str.replace(pat, my_function))
# S5.str.replace(pat, my_function)= 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_function(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])
print("S5.str.replace(pat, my_function)=",S5.str.replace(pat, my_function))
# S5.str.replace(pat, my_function)= 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
3.5 提取
提取既可以认为是一种返回具体元素（而不是布尔值或元素对应的索引位置）的匹配操作，也可以认为是一种特殊的拆分操作。前面提到的 str.split 例子中会把分隔符去除，这并不是用户想要的效果，这时候就可以用 str.extract 进行提取。
pat = '(\w+市)(\w+区)(\w+路)(\d+号)'
print("S5.str.extract(pat)=",S5.str.extract(pat))
# S5.str.extract(pat)= 0 1 2 3
# 0 上海市 黄浦区 方浜中路 249号
# 1 上海市 宝山区 密山路 5号
# 2 北京市 昌平区 北农路 2号
"通过子组的命名，可以直接对新生成 DataFrame 的列命名"
pat = '(?P<市名>\w+市)(?P<区名>\w+区)(?P<路名>\w+路)(?P<编号>\d+号)'
print("S5.str.extract(pat)=",S5.str.extract(pat))
# S5.str.extract(pat)= 市名 区名 路名 编号
# 0 上海市 黄浦区 方浜中路 249号
# 1 上海市 宝山区 密山路 5号
# 2 北京市 昌平区 北农路 2号
"str.extractall 不同于 str.extract ,它只匹配一次，它会把所有符合条件的模式全部匹配出来，如果存在多个结果，则以多级索引的方式存储"
S6=pd.Series(['A135T15,A26S5','B674S2,B25T6'], index = ['my_A','my_B'])
pat = '[A|B](\d+)[T|S](\d+)'
print("S6.str.extractall(pat)=",S6.str.extractall(pat))
# S6.str.extractall(pat)= 0 1
# match
# my_A 0 135 15
# 1 26 5
# my_B 0 674 2
# 1 25 6
pat_with_name = '[A|B](?P<name1>\d+)[T|S](?P<name2>\d+)'
print("S6.str.extractall(pat_with_name)=",S6.str.extractall(pat_with_name))
# S6.str.extractall(pat_with_name)= name1 name2
# match
# my_A 0 135 15
# 1 26 5
# my_B 0 674 2
# 1 25 6
"""
str.findall 的功能类似于 str.extractall ，区别在于前者把结果存入列表中，
而后者处理为多级索引，每个行只对应一组匹配，而不是把所有匹配组合构成列表
"""
print("S6.str.findall(pat)=",S6.str.findall(pat))
# S6.str.findall(pat)= my_A [(135, 15), (26, 5)]
# my_B [(674, 2), (25, 6)]
# dtype: object
四、常用字符串函数
Python字符串函数表
| 序号 | 函数 | 说明 |
|---|---|---|
| 1 | lower() | 将Series/Index中的字符串转换为小写。 |
| 2 | upper() | 将Series/Index中的字符串转换为大写。 |
| 3 | len() | 计算字符串长度。 |
| 4 | strip() | 帮助从两侧的系列/索引中的每个字符串中删除空格(包括换行符)。 |
| 5 | split(’ ') | 用给定的模式拆分每个字符串。 |
| 6 | cat(sep=’ ') | 使用给定的分隔符连接系列/索引元素。 |
| 7 | get_dummies() | 返回具有单热编码值的数据帧(DataFrame)。 |
| 8 | contains(pattern) | 如果元素中包含子字符串，则返回每个元素的布尔值True，否则为False。 |
| 9 | replace(a,b) | 将值a替换为值b。 |
| 10 | repeat(value) | 重复每个元素指定的次数。 |
| 11 | count(pattern) | 返回模式中每个元素的出现总数。 |
| 12 | startswith(pattern) | 如果系列/索引中的元素以模式开始，则返回true。 |
| 13 | endswith(pattern) | 如果系列/索引中的元素以模式结束，则返回true。 |
| 14 | find(pattern) | 返回模式第一次出现的位置。 |
| 15 | findall(pattern) | 返回模式的所有出现的列表。 |
| 16 | swapcase() | 变换字母大小写 |
| 17 | islower() | 检查系列/索引中每个字符串中的所有字符是否小写，返回布尔值 |
| 18 | isupper() | 检查系列/索引中每个字符串中的所有字符是否大写，返回布尔值 |
| 19 | isnumeric() | 检查系列/索引中每个字符串中的所有字符是否为数字，返回布尔值。 |
4.1 字母型函数
upper, lower, title, capitalize, swapcase 这五个函数主要用于字母的大小写转化。
Ser5 = pd.Series(['lower', 'CAPITALS', 'this is a sentence', 'upper'])
print("Ser5.str.upper()=",Ser5.str.upper())
# Ser5.str.upper()= 0 LOWER
# 1 CAPITALS
# 2 THIS IS A SENTENCE
# 3 UPPER
# dtype: object
print("Ser5.str.lower()=",Ser5.str.lower())
# Ser5.str.lower()= 0 lower
# 1 capitals
# 2 this is a sentence
# 3 upper
# dtype: object
print("Ser5.str.title()=",Ser5.str.title())
# Ser5.str.title()= 0 Lower
# 1 Capitals
# 2 This Is A Sentence
# 3 Upper
# dtype: object
print("Ser5.str.capitalize()=",Ser5.str.capitalize())
# Ser5.str.capitalize()= 0 Lower
# 1 Capitals
# 2 This is a sentence
# 3 Upper
# dtype: object
print("Ser5.str.swapcase()=",Ser5.str.swapcase())
# Ser5.str.swapcase()= 0 LOWER
# 1 capitals
# 2 THIS IS A SENTENCE
# 3 UPPER
# dtype: object
4.2 数值型函数
pd.to_numeric 方法，它虽然不是 str 对象上的方法，但是能够对字符格式的数值进行快速转换和筛选。其主要参数包括 errors 和 downcast 分别代表了非数值的处理模式和转换类型。其中，对于不能转换为数值的有三种 errors 选项， raise, coerce, ignore 分别表示直接报错、设为缺失以及保持原来的字符串。
Ser6 = pd.Series(['1', '2.2', '2e', '??', '-2.1', '0'])
print("pd.to_numeric(Ser6, errors='ignore')=",pd.to_numeric(Ser6, errors='ignore'))
# pd.to_numeric(Ser6, errors='ignore')= 0 1
# 1 2.2
# 2 2e
# 3 ??
# 4 -2.1
# 5 0
# dtype: object
print("pd.to_numeric(Ser6, errors='coerce')=",pd.to_numeric(Ser6, errors='coerce'))
# pd.to_numeric(Ser6, errors='coerce')= 0 1.0
# 1 2.2
# 2 NaN
# 3 NaN
# 4 -2.1
# 5 0.0
# dtype: float64
print("Ser6[pd.to_numeric(Ser6, errors='coerce').isna()]=",
Ser6[pd.to_numeric(Ser6, errors='coerce').isna()])
# Ser6[pd.to_numeric(Ser6, errors='coerce').isna()]= 2 2e
# 3 ??
# dtype: object
4.3 统计型函数
count 和 len 的作用分别是返回出现正则模式的次数和字符串的长度。
Ser7 = pd.Series(['cat rat fat at', 'get feed sheet heat'])
print("Ser7.str.count('[r|f]at|ee')=",Ser7.str.count('[r|f]at|ee'))
# Ser7.str.count('[r|f]at|ee')= 0 2
# 1 2
# dtype: int64
print("Ser5.str.len()=", Ser5.str.len())
# Ser5.str.len()= 0 5
# 1 8
# 2 18
# 3 5
# dtype: int64
4.4 格式型函数
格式型函数主要分为两类，第一种是除空型，第二种时填充型。其中，第一类函数一共有三种，它们分别是 strip, rstrip, lstrip ，分别代表去除两侧空格、右侧空格和左侧空格。这些函数在数据清洗时是有用的，特别是列名含有非法空格的时候。
my_index = pd.Index([' col1', 'col2 ', ' col3 '])
print(" my_index.str.strip().str.len()=", my_index.str.strip().str.len())
# my_index.str.strip().str.len()= Int64Index([4, 4, 4], dtype='int64')
print("my_index.str.rstrip().str.len()=",my_index.str.rstrip().str.len())
# my_index.str.rstrip().str.len()= Int64Index([5, 4, 5], dtype='int64')
print("my_index.str.lstrip().str.len()=",my_index.str.lstrip().str.len())
# my_index.str.lstrip().str.len()= Int64Index([4, 5, 5], dtype='int64')
"填充型函数而言， pad 是最灵活的，它可以选定字符串长度、填充的方向和填充内容"
Ser7 = pd.Series(['a','b','c','D','F'])
print("Ser7.str.pad(5,'left','*')=",Ser7.str.pad(5,'left','*'))
# Ser7.str.pad(5,'left','*')= 0 ****a
# 1 ****b
# 2 ****c
# 3 ****D
# 4 ****F
# dtype: object
print("Ser7.str.pad(5,'right','*')=",Ser7.str.pad(5,'right','*'))
# Ser7.str.pad(5,'right','*')= 0 a****
# 1 b****
# 2 c****
# 3 D****
# 4 F****
# dtype: object
print("Ser7.str.pad(5,'both','*')=",Ser7.str.pad(5,'both','*'))
# Ser7.str.pad(5,'both','*')= 0 **a**
# 1 **b**
# 2 **c**
# 3 **D**
# 4 **F**
# dtype: object
"分别用 rjust, ljust, center 来等效完成，需要注意 ljust 是指右侧填充而不是左侧填充"
print("Ser7.str.rjust(5, '*')=",Ser7.str.rjust(5, '*'))
# Ser7.str.rjust(5, '*')= 0 ****a
# 1 ****b
# 2 ****c
# 3 ****D
# 4 ****F
# dtype: object
print("Ser7.str.ljust(5, '*')=",Ser7.str.ljust(5, '*'))
# Ser7.str.ljust(5, '*')= 0 a****
# 1 b****
# 2 c****
# 3 D****
# 4 F****
# dtype: object
print("Ser7.str.center(5, '*')=",Ser7.str.center(5, '*'))
"""
在读取 excel 文件时，经常会出现数字前补0的需求，例如证券代码读入的时候会把”000007”作为数值7来处理， pandas 中除了可以使用上面的左侧填充函数进行操作之外，还可用 zfill 来实现
"""
Ser8 = pd.Series([7, 155, 303000]).astype('string')
print("Ser8.str.pad(6,'left','0')",Ser8.str.pad(6,'left','0'))
# Ser8.str.pad(6,'left','0') 0 000007
# 1 000155
# 2 303000
# dtype: string
print("Ser8.str.rjust(6,'0')=",Ser8.str.rjust(6,'0'))
# Ser8.str.rjust(6,'0')= 0 000007
# 1 000155
# 2 303000
# dtype: string
print("Ser8.str.zfill(6)=",Ser8.str.zfill(6))
# Ser8.str.zfill(6)= 0 000007
# 1 000155
# 2 303000
# dtype: string
参考文献
1、https://datawhalechina.github.io/joyful-pandas/build/html/%E7%9B%AE%E5%BD%95/ch8.html
扫一扫
856
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
