目录
307、pandas.Series.str.center方法
308、pandas.Series.str.contains函数
310、pandas.Series.str.decode函数
一、用法精讲
306、pandas.Series.str.cat方法
306-1、语法
# 306、pandas.Series.str.cat方法
pandas.Series.str.cat(others=None, sep=None, na_rep=None, join='left')
Concatenate strings in the Series/Index with given separator.
If others is specified, this function concatenates the Series/Index and elements of others element-wise. If others is not passed, then all values in the Series/Index are concatenated into a single string with a given sep.
Parameters:
othersSeries, Index, DataFrame, np.ndarray or list-like
Series, Index, DataFrame, np.ndarray (one- or two-dimensional) and other list-likes of strings must have the same length as the calling Series/Index, with the exception of indexed objects (i.e. Series/Index/DataFrame) if join is not None.
If others is a list-like that contains a combination of Series, Index or np.ndarray (1-dim), then all elements will be unpacked and must satisfy the above criteria individually.
If others is None, the method returns the concatenation of all strings in the calling Series/Index.
sepstr, default ‘’
The separator between the different elements/columns. By default the empty string ‘’ is used.
na_repstr or None, default None
Representation that is inserted for all missing values:
If na_rep is None, and others is None, missing values in the Series/Index are omitted from the result.
If na_rep is None, and others is not None, a row containing a missing value in any of the columns (before concatenation) will have a missing value in the result.
join{‘left’, ‘right’, ‘outer’, ‘inner’}, default ‘left’
Determines the join-style between the calling Series/Index and any Series/Index/DataFrame in others (objects without an index need to match the length of the calling Series/Index). To disable alignment, use .values on any Series/Index/DataFrame in others.
Returns:
str, Series or Index
If others is None, str is returned, otherwise a Series/Index (same type as caller) of objects is returned.306-2、参数
306-2-1、others(可选，默认值为None)：表示要与当前Series合并的其他Series，可以是一个Series对象的列表，或者是单个Series。
306-2-2、sep(可选，默认值为None)：用于连接字符串的分隔符，若为None，则不使用分隔符。
306-2-3、na_rep(可选，默认值为None)：指定如何表示缺失值(NaN)，若为None，则缺失值不会被替代。
306-2-4、join(可选，默认值为'left')：指定合并方式，选项有：
306-2-4-1、'left'：仅包含左侧Series中存在的索引。
306-2-4-2、'right'：仅包含右侧Series中存在的索引。
306-2-4-3、'outer'：包含所有索引(并集)。
306-2-4-4、'inner'：仅包含所有Series中都存在的索引(交集)。
306-3、功能
用于将多个字符串序列按指定的分隔符连接成一个新的字符串序列，它可以处理多个字符串列的合并，并提供了灵活的参数选项以满足不同的需求。
306-4、返回值
返回一个新的Series对象，其中每个元素都是合并后的字符串。
306-5、说明
使用场景：
306-5-1、数据整合：在数据分析中，通常需要将来自不同数据源的字符串数据合并。例如，将不同字段的信息合并为一个完整的描述字段，假设有两个Series分别包含用户的名字和姓氏，可以使用该方法将它们合并为全名。
306-5-2、生成报告或日志：当生成报告或日志时，可能需要将多个信息字段合并为一个字符串。例如，在日志记录中，你可能需要将时间戳、事件类型和消息内容合并为一个完整的日志条目。
306-5-3、数据清理：在数据清理过程中，可能会需要将不同列中的字符串合并，以便进一步分析或建模。例如，将地址的各个组成部分(街道、城市、州、邮政编码)合并为一个完整的地址字段。
306-5-4、特征工程：在机器学习中的特征工程阶段，可能会需要将多个特征列的字符串合并为一个特征，以便更好地捕捉数据中的模式。例如，将用户的兴趣爱好、职业和教育背景合并为一个综合的特征，用于模型训练。
306-5-5、数据可视化：在数据可视化过程中，可能需要将数据的不同部分合并为一个标签或标题，以提高图表的可读性。例如，将产品名称、类别和价格合并为图表中的标签。
306-5-6、数据格式化：在处理数据导出或报告生成时，可能需要将多个数据项合并为特定格式的字符串。例如，将日期、时间和地点合并为一个格式化的事件字符串。
306-6、用法
306-6-1、数据准备
无306-6-2、代码示例
# 306、pandas.Series.str.cat方法
# 306-1、数据整合：合并用户的名字和姓氏
import pandas as pd
# 创建包含名字和姓氏的Series
first_names = pd.Series(['John', 'Jane', 'Alice'])
last_names = pd.Series(['Doe', 'Smith', 'Johnson'])
# 合并名字和姓氏为全名
full_names = first_names.str.cat(last_names, sep=' ')
print(full_names, end='\n\n')
# 306-2、生成报告或日志：合并时间戳、事件类型和消息内容
import pandas as pd
# 创建包含时间戳、事件类型和消息内容的Series
timestamps = pd.Series(['2024-08-08 12:00', '2024-08-08 12:05'])
event_types = pd.Series(['INFO', 'ERROR'])
messages = pd.Series(['System started', 'Failed to connect'])
# 合并为完整的日志条目
logs = timestamps.str.cat([event_types, messages], sep=' - ')
print(logs, end='\n\n')
# 306-3、数据清理：合并地址的各个组成部分
import pandas as pd
# 创建包含地址各部分的 Series
street = pd.Series(['123 Main St', '456 Maple Ave'])
city = pd.Series(['Springfield', 'Hometown'])
state = pd.Series(['IL', 'CA'])
zip_code = pd.Series(['62701', '90210'])
# 合并为完整的地址
addresses = street.str.cat([city, state, zip_code], sep=', ')
print(addresses, end='\n\n')
# 306-4、特征工程：合并用户的兴趣爱好、职业和教育背景
import pandas as pd
# 创建包含用户兴趣爱好、职业和教育背景的Series
interests = pd.Series(['Reading, Hiking', 'Cooking, Traveling'])
occupations = pd.Series(['Engineer', 'Teacher'])
education = pd.Series(['PhD', 'Masters'])
# 合并为综合特征
features = interests.str.cat([occupations, education], sep=' | ')
print(features, end='\n\n')
# 306-5、数据可视化：生成条形图的标签
import pandas as pd
import matplotlib.pyplot as plt
# 创建包含产品名称、类别和价格的Series
product_names = pd.Series(['Laptop', 'Smartphone', 'Tablet'])
categories = pd.Series(['Electronics', 'Electronics', 'Electronics'])
prices = pd.Series(['$999', '$699', '$399'])
# 合并为图表标签
labels = product_names.str.cat([categories, prices], sep=' - ')
# 创建一个示例数据框
data = pd.DataFrame({
'Products': labels,
'Sales': [150, 200, 120] # 示例销售数据
})
# 绘制条形图
plt.figure(figsize=(10, 6))
plt.bar(data['Products'], data['Sales'], color='purple')
# 添加标题和标签
plt.title('Product Sales')
plt.xlabel('Product Details')
plt.ylabel('Sales')
# 旋转x轴标签，以便更好地显示
plt.xticks(rotation=45, ha='right')
# 显示图形
plt.tight_layout()
plt.show()
# 306-6、数据格式化：合并日期、时间和地点
import pandas as pd
# 创建包含日期、时间和地点的Series
dates = pd.Series(['2024-08-08', '2024-08-09'])
times = pd.Series(['09:00', '15:00'])
locations = pd.Series(['Conference Room A', 'Meeting Hall B'])
# 合并为格式化的事件字符串
events = dates.str.cat([times, locations], sep=' ')
print(events)306-6-3、结果输出
# 306、pandas.Series.str.cat方法
# 306-1、数据整合：合并用户的名字和姓氏
# 0 John Doe
# 1 Jane Smith
# 2 Alice Johnson
# dtype: object
# 306-2、生成报告或日志：合并时间戳、事件类型和消息内容
# 0 2024-08-08 12:00 - INFO - System started
# 1 2024-08-08 12:05 - ERROR - Failed to connect
# dtype: object
# 306-3、数据清理：合并地址的各个组成部分
# 0 123 Main St, Springfield, IL, 62701
# 1 456 Maple Ave, Hometown, CA, 90210
# dtype: object
# 306-4、特征工程：合并用户的兴趣爱好、职业和教育背景
# 0 Reading, Hiking | Engineer | PhD
# 1 Cooking, Traveling | Teacher | Masters
# dtype: object
# 306-5、数据可视化：生成条形图的标签
# 见图1
# 306-6、数据格式化：合并日期、时间和地点
# 0 2024-08-08 09:00 Conference Room A
# 1 2024-08-09 15:00 Meeting Hall B
# dtype: object图1：
307、pandas.Series.str.center方法
307-1、语法
# 307、pandas.Series.str.center方法
pandas.Series.str.center(width, fillchar=' ')
Pad left and right side of strings in the Series/Index.
Equivalent to str.center().
Parameters:
width
int
Minimum width of resulting string; additional characters will be filled with fillchar.
fillchar
str
Additional character for filling, default is whitespace.
Returns:
Series/Index of objects.307-2、参数
307-2-1、with(必须)：指定结果字符串的总宽度，如果字符串的长度小于width，则在字符串的两侧填充fillchar以达到指定的宽度；如果字符串的长度大于或等于width，则返回原始字符串。
307-2-2、fillchar(可选，默认值为空格字符' ')：用于填充的字符，该字符将会被添加到字符串的左右两侧，以便将字符串扩展到指定的宽度。需要注意的是，fillchar必须是一个长度为1的字符。
307-3、功能
用于将每个字符串元素居中对齐，该方法常用于需要对字符串进行格式化时，尤其是当你希望字符串在某个宽度内居中显示时。
307-4、返回值
Series或Index，具体取决于调用方法的对象。每个元素都被扩展或保持原样，以便其长度达到指定的width；如果某个元素的长度已经等于或超过width，则该元素将不被修改。
307-5、说明
使用场景：
307-5-1、文本对齐与格式化：在需要将文本居中对齐的场景中，此方法非常实用，无论是生成报表、打印输出还是构建文本表格，都需要确保每个文本单元格式统一、对齐整齐，通过使用该方法可以轻松地将字符串居中并填充左右两侧的空白，达到视觉上更美观的效果。
307-5-2、数据标准化：在数据清洗的过程中，经常会遇到不规则长度的字符串，为了后续处理的方便，有时需要将这些字符串统一为相同长度，该方法通过在字符串两侧添加指定字符，可以将所有字符串标准化为相同长度，从而简化数据处理过程。
307-5-3、文本界面显示：在命令行或控制台应用程序中，通常需要以美观的方式显示文本内容。例如，显示标题、菜单选项或提示信息时，通过使用该方法将文本居中，可以使界面更加整齐、美观。
307-5-4、报表生成：在生成文本报表或导出表格时，为了使各列数据对齐，可以使用该方法对数据进行格式化，通过统一每列数据的宽度，并将内容居中显示，报表看起来会更加规范和专业。
307-5-5、美观的用户界面：如果你在设计用户界面时需要展示一组居中的文本元素，例如按钮或标签，可以使用该方法将文本居中，使整个界面看起来更对称和美观。
307-6、用法
307-6-1、数据准备
无307-6-2、代码示例
# 307、pandas.Series.str.center方法
# 307-1、文本对齐与格式化
import pandas as pd
# 创建列标题
headers = pd.Series(['Product Name', 'Price', 'Quantity'])
# 将列标题居中对齐并填充空格
centered_headers = headers.str.center(20)
print(centered_headers, end='\n\n')
# 307-2、数据标准化
import pandas as pd
# 创建公司名称列表
companies = pd.Series(['Apple', 'Microsoft', 'Google', 'Amazon'])
# 将公司名称居中对齐并填充'*'，统一长度为15个字符
centered_companies = companies.str.center(15, '*')
print(centered_companies, end='\n\n')
# 307-3、文本界面显示
import pandas as pd
# 创建菜单选项列表
menu_options = pd.Series(['Start Game', 'Options', 'Quit'])
# 将菜单选项居中对齐并填充'-'
centered_menu = menu_options.str.center(30, '-')
print(centered_menu, end='\n\n')
# 307-4、报表生成
import pandas as pd
# 创建报表数据
data = {
'Product': ['Laptop', 'Smartphone', 'Tablet', 'Monitor'],
'Price': [999.99, 699.99, 499.99, 199.99],
'Quantity': [10, 20, 15, 7]
}
# 创建DataFrame
df = pd.DataFrame(data)
# 对Product列进行居中对齐并填充空格
df['Product'] = df['Product'].str.center(15)
# 打印格式化后的报表
print(df, end='\n\n')
# 307-5、美观的用户界面
import pandas as pd
# 创建按钮标签列表
buttons = pd.Series(['OK', 'Cancel', 'Apply'])
# 将按钮标签居中对齐并填充'='，统一长度为10个字符
centered_buttons = buttons.str.center(10, '=')
print(centered_buttons)307-6-3、结果输出
# 307、pandas.Series.str.center方法
# 307-1、文本对齐与格式化
# 0 Product Name
# 1 Price
# 2 Quantity
# dtype: object
# 307-2、数据标准化
# 0 *****Apple*****
# 1 ***Microsoft***
# 2 *****Google****
# 3 *****Amazon****
# dtype: object
# 307-3、文本界面显示
# 0 ----------Start Game----------
# 1 -----------Options------------
# 2 -------------Quit-------------
# dtype: object
# 307-4、报表生成
# Product Price Quantity
# 0 Laptop 999.99 10
# 1 Smartphone 699.99 20
# 2 Tablet 499.99 15
# 3 Monitor 199.99 7
# 307-5、美观的用户界面
# 0 ====OK====
# 1 ==Cancel==
# 2 ==Apply===
# dtype: object308、pandas.Series.str.contains函数
308-1、语法
# 308、pandas.Series.str.contains函数
pandas.Series.str.contains(pat, case=True, flags=0, na=None, regex=True)
Test if pattern or regex is contained within a string of a Series or Index.
Return boolean Series or Index based on whether a given pattern or regex is contained within a string of a Series or Index.
Parameters:
patstr
Character sequence or regular expression.
casebool, default True
If True, case sensitive.
flagsint, default 0 (no flags)
Flags to pass through to the re module, e.g. re.IGNORECASE.
nascalar, optional
Fill value for missing values. The default depends on dtype of the array. For object-dtype, numpy.nan is used. For StringDtype, pandas.NA is used.
regexbool, default True
If True, assumes the pat is a regular expression.
If False, treats the pat as a literal string.
Returns:
Series or Index of boolean values
A Series or Index of boolean values indicating whether the given pattern is contained within the string of each element of the Series or Index.308-2、参数
308-2-1、pat(必须)：指定要匹配的模式或字符串，这是你要在Series中查找的字符串模式，可以是简单的字符串或正则表达式。
308-2-2、case(可选，默认值为True)：指定是否区分大小写，如果为True，则匹配时区分大小写；如果为False，则忽略大小写。
308-2-3、flags(可选，默认值为0)：控制正则表达式匹配的标志，用于修改正则表达式的行为。例如，re.IGNORECASE(flags=re.I)可以与case=False类似，实现忽略大小写的匹配。
308-2-4、na(可选，默认值为None)：指定在Series元素为缺失值时返回的布尔值，如果设置为True或False，缺失值将被替换为该布尔值；如果设置为None，缺失值将保持不变。
308-2-5、regex(可选，默认值为True)：指定pat是否作为正则表达式进行处理，如果为True，则pat将被解释为正则表达式；如果为False，pat将被解释为普通的字符串。如果你不需要使用正则表达式，可以将其设置为False，以提高匹配速度。
308-3、功能
用于检查每个字符串元素是否包含特定的模式(pat)，并返回布尔值(True或False)的Series，用于标识每个元素是否包含该模式。
308-4、返回值
返回一个布尔值的Series，每个元素对应原Series的一个元素，如果该元素包含匹配的模式，则返回True，否则返回False。
308-5、说明
使用场景：
308-5-1、数据筛选与过滤：在一列包含字符串的数据中，查找包含特定关键词的行。例如，从新闻标题中筛选出包含某个关键词的文章。
308-5-2、数据清洗与预处理：检查数据中的字符串是否符合预期的模式。例如，检查电子邮件字段是否包含“@”符号，以识别无效的电子邮件地址。
308-5-3、特征工程：在构建机器学习模型时，将字符串数据中的模式匹配结果作为特征。例如，判断客户评论中是否包含正面或负面的关键词。
308-5-4、异常值检测：在文本数据中识别不常见或异常的模式。例如，在地址字段中检查是否包含无效字符或格式。
308-5-5、分类与标记：根据特定模式对数据进行分类或标记。例如，根据文章标题中是否包含“Breaking”来标记紧急新闻。
308-5-6、数据对比：比较不同数据源中的字符串字段，找出共同特征或差异。例如，比较用户输入的地址与标准地址列表是否匹配。
308-5-7、正则表达式的应用：通过正则表达式匹配复杂的字符串模式。例如，提取日志文件中的特定日志类型或错误信息。
308-6、用法
308-6-1、数据准备
无308-6-2、代码示例
# 308、pandas.Series.str.contains函数
# 308-1、数据筛选与过滤
import pandas as pd
# 示例数据
data = pd.Series(['apple pie', 'banana bread', 'apple juice', 'grape soda'])
# 筛选包含“apple”的行
apple_products = data[data.str.contains('apple')]
print(apple_products, end='\n\n')
# 308-2、数据清洗与预处理
import pandas as pd
# 示例数据
emails = pd.Series(['test@example.com', 'invalidemail.com', 'user@domain.com', 'another.invalidemail'])
# 筛选不包含“@”符号的行
invalid_emails = emails[~emails.str.contains('@')]
print(invalid_emails, end='\n\n')
# 308-3、特征工程
import pandas as pd
# 示例数据
data = pd.DataFrame({
'review': ['This is good', 'Very bad experience', 'Good value for money', 'Not good at all']
})
# 创建一个新特征，表示评论中是否包含“good”
data['contains_good'] = data['review'].str.contains('good', case=False)
print(data, end='\n\n')
# 308-4、异常值检测
import pandas as pd
# 示例数据
addresses = pd.Series(['123 Main St.', '456 Elm St.', '!@#$% Invalid', '789 Oak St.'])
# 查找包含无效字符的地址
invalid_addresses = addresses[addresses.str.contains('[!@#$%^&*()]', regex=True)]
print(invalid_addresses, end='\n\n')
# 308-5、分类与标记
import pandas as pd
# 示例数据
data = pd.DataFrame({
'title': ['Breaking News: Market Crash', 'Daily Update', 'Breaking: New Law Passed', 'Weather Report']
})
# 标记标题中包含“Breaking”的行
data['is_breaking'] = data['title'].str.contains('Breaking')
print(data, end='\n\n')
# 308-6、数据对比
import pandas as pd
# 示例数据
user_addresses = pd.Series(['123 Main St.', '456 Elm St.', '789 Oak St.', 'Unknown Address'])
standard_addresses = ['123 Main St.', '456 Elm St.', '789 Oak St.']
# 筛选出与标准地址匹配的用户输入地址
matched_addresses = user_addresses[user_addresses.str.contains('|'.join(standard_addresses))]
print(matched_addresses, end='\n\n')
# 308-7、正则表达式的应用
import pandas as pd
# 示例数据
logs = pd.Series(['INFO: System running', 'ERROR: Disk full', 'INFO: Backup completed', 'ERROR: Network down'])
# 提取包含“ERROR”的日志行
error_logs = logs[logs.str.contains('ERROR')]
print(error_logs)308-6-3、结果输出
# 308、pandas.Series.str.contains函数
# 308-1、数据筛选与过滤
# 0 apple pie
# 2 apple juice
# dtype: object
# 308-2、数据清洗与预处理
# 1 invalidemail.com
# 3 another.invalidemail
# dtype: object
# 308-3、特征工程
# review contains_good
# 0 This is good True
# 1 Very bad experience False
# 2 Good value for money True
# 3 Not good at all True
# 308-4、异常值检测
# 2 !@#$% Invalid
# dtype: object
# 308-5、分类与标记
# title is_breaking
# 0 Breaking News: Market Crash True
# 1 Daily Update False
# 2 Breaking: New Law Passed True
# 3 Weather Report False
# 308-6、数据对比
# 0 123 Main St.
# 1 456 Elm St.
# 2 789 Oak St.
# dtype: object
# 308-7、正则表达式的应用
# 1 ERROR: Disk full
# 3 ERROR: Network down
# dtype: object309、pandas.Series.str.count方法
309-1、语法
# 309、pandas.Series.str.count方法
pandas.Series.str.count(pat, flags=0)
Count occurrences of pattern in each string of the Series/Index.
This function is used to count the number of times a particular regex pattern is repeated in each of the string elements of the Series.
Parameters:
pat
str
Valid regular expression.
flags
int, default 0, meaning no flags
Flags for the re module. For a complete list, see here.
**kwargs
For compatibility with other string methods. Not used.
Returns:
Series or Index
Same type as the calling object containing the integer counts.309-2、参数
309-2-1、pat(必须)：一个正则表达式模式，用于匹配字符串中的子字符串，可以是简单的字符，也可以是复杂的正则表达式。
309-2-2、flags(可选，默认值为0)：用于正则表达式的标志，可以修改正则表达式的行为，常用的标志包括：
- re.IGNORECASE或re.I：忽略大小写匹配。
- re.MULTILINE或re.M：将每行视为单独的字符串，允许^和
$匹配每行的开始和结束。 - re.DOTALL或re.S：让
.匹配包括换行符在内的所有字符。 - re.VERBOSE或re.X：允许你写更具可读性的正则表达式。
309-3、功能
对每个字符串值应用正则表达式模式，并返回该模式在字符串中出现的次数，它可以用于整个Series，也就是每个字符串元素都会单独计算匹配次数。
309-4、返回值
返回一个与原始Series 具有相同索引的新的Series，每个元素都是一个整数，表示pat在相应字符串中出现的次数。
309-5、说明
无
309-6、用法
309-6-1、数据准备
无309-6-2、代码示例
# 309、pandas.Series.str.count方法
# 309-1、基本用法
import pandas as pd
# 示例数据
data = pd.Series(['apple', 'banana', 'cherry', 'date', 'apple pie'])
# 统计每个字符串中 'a' 的出现次数
a_count = data.str.count('a')
print(a_count, end='\n\n')
# 309-2、使用flags参数
import pandas as pd
import re
# 示例数据
data = pd.Series(['Apple', 'banana', 'Cherry', 'Date', 'apple pie'])
# 统计每个字符串中'a'的出现次数，忽略大小写
a_count_case_insensitive = data.str.count('a', flags=re.IGNORECASE)
print(a_count_case_insensitive)309-6-3、结果输出
# 309、pandas.Series.str.count方法
# 309-1、基本用法
# 0 1
# 1 3
# 2 0
# 3 1
# 4 1
# dtype: int64
# 309-2、使用flags参数
# 0 1
# 1 3
# 2 0
# 3 1
# 4 1
# dtype: int64310、pandas.Series.str.decode函数
310-1、语法
# 310、pandas.Series.str.decode函数
pandas.Series.str.decode(encoding, errors='strict')
Decode character string in the Series/Index using indicated encoding.
Equivalent to str.decode() in python2 and bytes.decode() in python3.
Parameters:
encoding
str
errors
str, optional
Returns:
Series or Index310-2、参数
310-2-1、encoding(必须)：字符串，指定要使用的字符编码类型，例如'utf-8'、'ascii'、'latin-1'等，该参数定义了如何将二进制数据解码为字符串。
310-2-2、errors(可选，默认值为'strict')：定义在解码过程中遇到错误时的处理方式，可选值如下：
- 'strict'(默认值)：遇到无法解码的字节时会引发一个UnicodeDecodeError。
- 'ignore'：忽略无法解码的字节，不会引发错误，也不会在结果中包含这些字节。
- 'replace'：用替代字符(通常是?或\uFFFD)代替无法解码的字节。
- 'backslashreplace'：将无法解码的字节替换为反斜杠转义序列。
- 'namereplace'：将无法解码的字节替换为\N{...}名称转义序列。
- 'xmlcharrefreplace'：将无法解码的字节替换为XML字符引用。
310-3、功能
用于对Series对象中的字符串进行解码，该方法会尝试将每个字符串解码为指定的编码，并根据errors参数处理可能的解码错误。
310-4、返回值
返回一个新的Series或Index对象，其中的元素为解码后的字符串，如果解码过程中发生错误，且errors参数设置为'ignore'、'replace'等，错误处理将影响返回值的内容。
310-5、说明
无
310-6、用法
310-6-1、数据准备
无310-6-2、代码示例
# 310、pandas.Series.str.decode函数
import pandas as pd
# 创建一个Series对象，其中包含以UTF-8编码的字节字符串
s = pd.Series([b'\xe4\xbd\xa0\xe5\xa5\xbd', b'\xe4\xb8\x96\xe7\x95\x8c'])
# 对字节字符串进行解码，使用UTF-8编码
decoded_s = s.str.decode(encoding='utf-8')
print(decoded_s)310-6-3、结果输出
# 310、pandas.Series.str.decode函数
# 0 你好
# 1 世界
# dtype: object