PySpark3：pyspark.sql.functions常见的60个函数
目录
一、常见的60个函数
首先创建一个用于测试的DataFrame：
from pyspark.sql import SparkSession
from pyspark.sql import functions as F
# 初始化 SparkSession
spark = SparkSession.builder.appName("test").getOrCreate()
# 创建一个 DataFrame
data = [("James", "Smith", "USA", "CA", "1999/04/15", 60.86, "football|swimming|playing the guitar", None),
("Michael", "Rose", "USA", "NY", "1995/03/01", 80.0, "reading books|gardening|collecting stamps", "phone number:123456"),
("Robert", "Williams", None, None, "1997/10/31", 91.0, "photography", " outgoing "),
("Maria", "Jones", "USA", "FL", "1991/01/25", 59.5, None, " a diligent student. ")]
columns = ["firstname", "lastname", "country", "state", "birthday", "score", "hobbies", "remarks"]
df = spark.createDataFrame(data, schema=columns)
df.show()
'''
+---------+--------+-------+-----+----------+-----+--------------------+--------------------+
|firstname|lastname|country|state| birthday|score| hobbies| remarks|
+---------+--------+-------+-----+----------+-----+--------------------+--------------------+
| James| Smith| USA| CA|1999/04/15|60.86|football|swimming...| NULL|
| Michael| Rose| USA| NY|1995/03/01| 80.0|reading books|gar...| phone number:123456|
| Robert|Williams| NULL| NULL|1997/10/31| 91.0| photography| outgoing |
| Maria| Jones| USA| FL|1991/01/25| 59.5| NULL| a diligent stude...|
+---------+--------+-------+-----+----------+-----+--------------------+--------------------+
'''1、col
用于通过列名获取列对象，在选择列、进行列相关操作时经常使用。
df.select(F.col("firstname"), F.col("lastname")).show()
'''
+---------+--------+
|firstname|lastname|
+---------+--------+
| James| Smith|
| Michael| Rose|
| Robert|Williams|
| Maria| Jones|
+---------+--------+
'''有的时候PySpark在内部会将字符串自动转换为Column对象，例如select方法可以接受字符串列表，并且PySpark会将这些字符串解释为DataFrame中的列名，所以可以省略col：
df.select("firstname", "lastname")但在执行更复杂的操作，如对列进行函数调用或组合列，那么必须使用col：
df.select(F.col("score")+0.5)2、lit
lit函数用于创建一个包含常量值的Column对象，可以向DataFrame添加常量值或作为条件表达式的一部分。
df.select(F.col("firstname"), F.lit("Member").alias("type"), F.lit(0).alias("number")).show()
'''
+---------+------+------+
|firstname| type|number|
+---------+------+------+
| James|Member| 0|
| Michael|Member| 0|
| Robert|Member| 0|
| Maria|Member| 0|
+---------+------+------+
'''3、sum
对指定列进行求和操作，常用于数据分析中计算数值列的总和。
df.select(F.sum("score").alias("score_sum")).show()
'''
+---------+
|score_sum|
+---------+
| 291.36|
+---------+
'''4、avg/mean
计算指定列的平均值。
df.select(F.avg("score").alias("score_avg"),
F.mean("score").alias("score_mean")).show()
'''
+---------+----------+
|score_avg|score_mean|
+---------+----------+
| 72.84| 72.84|
+---------+----------+
'''5、count
统计行数。
df.select(F.count("*")).show()
'''
+--------+
|count(1)|
+--------+
| 4|
+--------+
'''6、max
获取指定列中的最大值。
df.select(F.max("score").alias("score_max")).show()
'''
+---------+
|score_max|
+---------+
| 91.0|
+---------+
'''7、min
获取指定列中的最小值。
df.select(F.min("score").alias("score_min")).show()
'''
+---------+
|score_min|
+---------+
| 59.5|
+---------+
'''8、concat
用于将多个字符串列或者字符串字面量拼接成一个新的字符串。
df.select((F.concat(F.col("firstname"), F.lit("·"), F.col("lastname"))).alias("fullname")).show()
'''
+---------------+
| fullname|
+---------------+
| James·Smith|
| Michael·Rose|
|Robert·Williams|
| Maria·Jones|
+---------------+
'''9、substring
从字符串列中截取指定位置和长度的子字符串。
df.select(F.substring("birthday", 1, 4).alias("birthyear")).show()
'''
+---------+
|birthyear|
+---------+
| 1999|
| 1995|
| 1997|
| 1991|
+---------+
'''10、lower
将字符串列中的所有字符转换为小写，常用于文本标准化等场景。
df.select(F.lower("country")).show()
'''
+--------------+
|lower(country)|
+--------------+
| usa|
| usa|
| NULL|
| usa|
+--------------+
'''11、upper
和lower函数相反，upper将字符串列中的所有字符转换为大写。
df.select(F.upper("firstname")).show()
'''
+----------------+
|upper(firstname)|
+----------------+
| JAMES|
| MICHAEL|
| ROBERT|
| MARIA|
+----------------+
'''12、trim
去除字符串列两端的空白字符（空格、制表符等），清理输入文本时常用。
df.select(F.trim("remarks")).show()
'''
+-------------------+
| trim(remarks)|
+-------------------+
| NULL|
|phone number:123456|
| outgoing|
|a diligent student.|
+-------------------+
'''13、ltrim
只去除字符串列左边的空白字符。
df.select(F.ltrim("remarks")).show()
'''
+--------------------+
| ltrim(remarks)|
+--------------------+
| NULL|
| phone number:123456|
| outgoing |
|a diligent studen...|
+--------------------+
'''14、rtrim
只去除字符串列左边的空白字符。
df.select(F.rtrim("remarks")).show()
'''
+--------------------+
| rtrim(remarks)|
+--------------------+
| NULL|
| phone number:123456|
| outgoing|
| a diligent student.|
+--------------------+
'''15、split
按照指定分隔符将字符串列分割成数组。
df = df.withColumn("hobby_list",F.split("hobbies", "\|"))
df.select("hobby_list").show()
'''
+--------------------+
| hobby_list|
+--------------------+
|[football, swimmi...|
|[reading books, g...|
| [photography]|
| NULL|
+--------------------+
'''16、explode
将包含数组的列展开，每行对应数组中的一个元素，常用于处理一对多的数据关系。
df.select("firstname", F.explode("hobby_list")).show()
'''
+---------+------------------+
|firstname| col|
+---------+------------------+
| James| football|
| James| swimming|
| James|playing the guitar|
| Michael| reading books|
| Michael| gardening|
| Michael| collecting stamps|
| Robert| photography|
+---------+------------------+
'''17、collect_list
将指定列的值收集成一个列表（数组），常用于分组后把某列的值聚合起来。
df.groupBy("country").agg(F.collect_list("firstname")).show()
'''
+-------+-----------------------+
|country|collect_list(firstname)|
+-------+-----------------------+
| USA| [James, Michael, ...|
| NULL| [Robert]|
+-------+-----------------------+
'''18、collect_set
类似collect_list，不过它会去除重复元素，将指定列的值收集成一个去重后的集合（数组）。
df.groupBy("country").agg(F.collect_set("firstname")).show()
'''
+-------+----------------------+
|country|collect_set(firstname)|
+-------+----------------------+
| USA| [Maria, Michael, ...|
| NULL| [Robert]|
+-------+----------------------+
'''19、asc
指定升序排序，但其实升序是默认的，也可以不指定。
df.select("firstname","score").orderBy(F.asc("score")).show()
'''
+---------+-----+
|firstname|score|
+---------+-----+
| Maria| 59.5|
| James|60.86|
| Michael| 80.0|
| Robert| 91.0|
+---------+-----+
'''20、desc
指定降序排序。
df.select("firstname","score").orderBy(F.desc("score")).show()
'''
+---------+-----+
|firstname|score|
+---------+-----+
| Robert| 91.0|
| Michael| 80.0|
| James|60.86|
| Maria| 59.5|
+---------+-----+
'''21、when
用于实现类似条件判断的操作，构建条件表达式来生成新列或者更新列值。
类似于SQL中的“case when … then … when … then … else … end”结构。
df.select("score", F.when(F.col("score") >= 90, "Grade A")\
.when(F.col("score") >= 80, "Grade B")\
.when(F.col("score") >= 70, "Grade C")\
.when(F.col("score") >= 60, "Grade D")\
.otherwise("Grade E").alias("grade")).show()
'''
+-----+-------+
|score| grade|
+-----+-------+
|60.86|Grade D|
| 80.0|Grade B|
| 91.0|Grade A|
| 59.5|Grade E|
+-----+-------+
'''22、to_date
将字符串类型的日期数据转换为日期格式，方便后续日期相关运算
df = df.withColumn("birthday", F.to_date("birthday", "yyyy/MM/dd"))
df.select("birthday").show()
'''
+----------+
| birthday|
+----------+
|1999-04-15|
|1995-03-01|
|1997-10-31|
|1991-01-25|
+----------+
'''23、current_date
获取当前的日期。
df.select(F.current_date()).show()
'''
+--------------+
|current_date()|
+--------------+
| 2024-11-20|
| 2024-11-20|
| 2024-11-20|
| 2024-11-20|
+--------------+
'''24、datediff
计算两个日期列之间的天数差值。
df.select(F.datediff(F.current_date(), "birthday")).show()
'''
+----------------------------------+
|datediff(current_date(), birthday)|
+----------------------------------+
| 9351|
| 10857|
| 9882|
| 12353|
+----------------------------------+
'''25、date_add
在指定日期列基础上增加一定天数。
df.select("birthday", F.date_add("birthday", 1)).show()
'''
+----------+---------------------+
| birthday|date_add(birthday, 1)|
+----------+---------------------+
|1999-04-15| 1999-04-16|
|1995-03-01| 1995-03-02|
|1997-10-31| 1997-11-01|
|1991-01-25| 1991-01-26|
+----------+---------------------+
'''26、date_sub
和date_add相反，date_sub是在指定日期列基础上减去一定天数。
df.select("birthday", F.date_sub("birthday", 1)).show()
'''
+----------+---------------------+
| birthday|date_sub(birthday, 1)|
+----------+---------------------+
|1999-04-15| 1999-04-14|
|1995-03-01| 1995-02-28|
|1997-10-31| 1997-10-30|
|1991-01-25| 1991-01-24|
+----------+---------------------+
'''27、year
从日期列中提取年份部分。
df.select(F.year("birthday")).show()
'''
+--------------+
|year(birthday)|
+--------------+
| 1999|
| 1995|
| 1997|
| 1991|
+--------------+
'''28、month
提取日期列中的月份部分。
df.select(F.month("birthday")).show()
'''
+---------------+
|month(birthday)|
+---------------+
| 4|
| 3|
| 10|
| 1|
+---------------+
'''29、day
提取日期列中的日部分。
df.select(F.day("birthday")).show()
'''
+-------------+
|day(birthday)|
+-------------+
| 15|
| 1|
| 31|
| 25|
+-------------+
'''30、cast
用于数据类型转换，比如把时间类型转成字符串类型。
df.select(F.cast('string',F.col("birthday")).alias("birthday_str")).show()
'''
+------------+
|birthday_str|
+------------+
| 1999-04-15|
| 1995-03-01|
| 1997-10-31|
| 1991-01-25|
+------------+
'''或者，也可使用Column对象的绑定方法：
df.select(F.col("birthday").cast("string").alias("birthday_str")).show()31、round
对数值列进行四舍五入操作，指定保留的小数位数。
df.select(F.round("score", 1), F.round("score", -1)).show()
'''
+---------------+----------------+
|round(score, 1)|round(score, -1)|
+---------------+----------------+
| 60.9| 60.0|
| 80.0| 80.0|
| 91.0| 90.0|
| 59.5| 60.0|
+---------------+----------------+
'''32、ceil
向上取整，对数值列取大于等于它的最小整数。
df.select(F.ceil("score")).show()
'''
+-----------+
|CEIL(score)|
+-----------+
| 61|
| 80|
| 91|
| 60|
+-----------+
'''33、floor
向下取整，对数值列取小于等于它的最小整数。
df.select(F.floor("score")).show()
'''
+------------+
|FLOOR(score)|
+------------+
| 60|
| 80|
| 91|
| 59|
+------------+
'''34、coalesce
从多个列中选择第一个非空值的列作为结果列，常用于处理可能存在空值替换的情况。
df.select(F.coalesce("hobbies", "remarks")).show()
'''
+--------------------------+
|coalesce(hobbies, remarks)|
+--------------------------+
| football|swimming...|
| reading books|gar...|
| photography|
| a diligent stude...|
+--------------------------+
'''也可以使用nvl（只能传入两列）、nvl2（只能传入三列），相比之下，还是coalesce函数（不限制列数）更好用一些。
35、isnull
判断列中的值是否为 null，常配合条件判断使用，比如筛选出某列值为 null 的行。
df.filter(F.isnull("hobbies")).show()
'''
+---------+--------+-------+-----+----------+-----+-------+--------------------+
|firstname|lastname|country|state| birthday|score|hobbies| remarks|
+---------+--------+-------+-----+----------+-----+-------+--------------------+
| Maria| Jones| USA| FL|1991/01/25| 59.5| NULL| a diligent stude...|
+---------+--------+-------+-----+----------+-----+-------+--------------------+
'''36、isnotnull
df.filter(F.isnotnull("hobbies")).show()
'''
+---------+--------+-------+-----+----------+-----+--------------------+-------------------+
|firstname|lastname|country|state| birthday|score| hobbies| remarks|
+---------+--------+-------+-----+----------+-----+--------------------+-------------------+
| James| Smith| USA| CA|1999/04/15|60.86|football|swimming...| NULL|
| Michael| Rose| USA| NY|1995/03/01| 80.0|reading books|gar...|phone number:123456|
| Robert|Williams| NULL| NULL|1997/10/31| 91.0| photography| outgoing |
+---------+--------+-------+-----+----------+-----+--------------------+-------------------+
'''37、like
用于字符串的模糊匹配，类似 SQL 中的 LIKE 操作符。
df.select(F.col("firstname").like("J%"))
'''
+-----------------+
|firstname LIKE J%|
+-----------------+
| true|
| false|
| false|
| false|
+-----------------+
'''
df.filter(F.col("firstname").like("J%")).show()
'''
+---------+--------+-------+-----+----------+-----+--------------------+-------+
|firstname|lastname|country|state| birthday|score| hobbies|remarks|
+---------+--------+-------+-----+----------+-----+--------------------+-------+
| James| Smith| USA| CA|1999/04/15|60.86|football|swimming...| NULL|
+---------+--------+-------+-----+----------+-----+--------------------+-------+
'''38、rlike
使用正则表达式进行字符串匹配，更灵活地进行文本匹配筛选。
df.filter(F.col("remarks").rlike(".*[0-9].*")).show()
'''
+---------+--------+-------+-----+----------+-----+--------------------+-------------------+
|firstname|lastname|country|state| birthday|score| hobbies| remarks|
+---------+--------+-------+-----+----------+-----+--------------------+-------------------+
| Michael| Rose| USA| NY|1995/03/01| 80.0|reading books|gar...|phone number:123456|
+---------+--------+-------+-----+----------+-----+--------------------+-------------------+
'''39、size
用于获取数组列中元素的个数，若为Null值则返回-1。
df.select("hobby_list",F.size("hobby_list")).show()
'''
+--------------------+----------------+
| hobby_list|size(hobby_list)|
+--------------------+----------------+
|[football, swimmi...| 3|
|[reading books, g...| 3|
| [photography]| 1|
| NULL| -1|
+--------------------+----------------+
'''40、array_contains
判断数组列中是否包含指定元素。
df.filter(F.array_contains("hobby_list", "football")).show()
'''
+---------+--------+-------+-----+----------+-----+--------------------+-------+--------------------+
|firstname|lastname|country|state| birthday|score| hobbies|remarks| hobby_list|
+---------+--------+-------+-----+----------+-----+--------------------+-------+--------------------+
| James| Smith| USA| CA|1999-04-15|60.86|football|swimming...| NULL|[football, swimmi...|
+---------+--------+-------+-----+----------+-----+--------------------+-------+--------------------+
'''41、element_at
从数组列中获取指定位置的元素，比如获取列表中的第2个因元素。若没有第二个元素，则返回Null值。
df.select(F.element_at("hobby_list", 2)).show()
'''
+-------------------------+
|element_at(hobby_list, 2)|
+-------------------------+
| swimming|
| gardening|
| NULL|
| NULL|
+-------------------------+
'''42、array_join
将数组列中的元素用指定分隔符拼接成字符串，用法与split函数相反。
df.select(F.array_join("hobby_list", "|")).show()
'''
+-------------------------+
|array_join(hobby_list, |)|
+-------------------------+
| football|swimming...|
| reading books|gar...|
| photography|
| NULL|
+-------------------------+
'''43、struct
用于创建包含多个字段的结构体列，常用于嵌套数据结构的构建，例如把姓名和出生年月组合成一个结构体列。
df = df.withColumn("person_info", F.struct(F.col("firstname"), F.col("lastname"), F.col("birthday")))
df.select("person_info").show()
'''
+--------------------+
| person_info|
+--------------------+
|{James, Smith, 19...|
|{Michael, Rose, 1...|
|{Robert, Williams...|
|{Maria, Jones, 19...|
+--------------------+
'''44、expr
允许用户以字符串的形式编写 SQL 表达式，并将其应用到 DataFrame 上。
df.select(F.expr("person_info.firstname")).show()
'''
+---------+
|firstname|
+---------+
| James|
| Michael|
| Robert|
| Maria|
+---------+
'''或者，也可使用以下代码，作用相同：
df.selectExpr("person_info.firstname").show()45、create_map
创建一个键值对形式的映射（字典）列。
df = df.withColumn("person_map", F.create_map(F.col("firstname"), F.col("birthday")))
df.select("person_map").show()
'''
+--------------------+
| person_map|
+--------------------+
|{James -> 1999-04...|
|{Michael -> 1995-...|
|{Robert -> 1997-1...|
|{Maria -> 1991-01...|
+--------------------+
'''46、map_keys
获取映射列中所有的键组成的数组。
df.select(F.map_keys("person_map")).show()
'''
+--------------------+
|map_keys(person_map)|
+--------------------+
| [James]|
| [Michael]|
| [Robert]|
| [Maria]|
+--------------------+
'''47、map_values
获取映射列中所有的键组成的数组。
df.select(F.map_values("person_map")).show()
'''
+----------------------+
|map_values(person_map)|
+----------------------+
| [1999-04-15]|
| [1995-03-01]|
| [1997-10-31]|
| [1991-01-25]|
+----------------------+
'''48、translate
根据给定的字符映射关系来替换字符串中的字符。
df.select(F.translate("remarks", "123456", "#")).show()
'''
+-----------------------------+
|translate(remarks, 123456, #)|
+-----------------------------+
| NULL|
| phone number:#|
| outgoing |
| a diligent stude...|
+-----------------------------+
'''49、regexp_replace
按照指定的正则表达式模式来替换字符串中的内容，例如把一个文本列中所有的数字替换为#符号。
df.select(F.regexp_replace("remarks", "\\d", "#")).show()
'''
+---------------------------------+
|regexp_replace(remarks, \d, #, 1)|
+---------------------------------+
| NULL|
| phone number:######|
| outgoing |
| a diligent stude...|
+---------------------------------+
'''50、flatten
将一个数组（Array）类型的列转换为一个包含所有元素的扁平化列表，常用于处理嵌套结构的数据。
df = df.withColumn("array", F.lit([[1,2], [3,4]]))
df.select(F.flatten("array")).show()
'''
+--------------+
|flatten(array)|
+--------------+
| [1, 2, 3, 4]|
| [1, 2, 3, 4]|
| [1, 2, 3, 4]|
| [1, 2, 3, 4]|
+--------------+
'''51、sort_array
对数组类型的列按照元素的值进行排序，可以指定升序或者降序等排序规则。
df.select(F.sort_array(F.flatten("array"), asc=False)).show()
'''
+---------------------------------+
|sort_array(flatten(array), false)|
+---------------------------------+
| [4, 3, 2, 1]|
| [4, 3, 2, 1]|
| [4, 3, 2, 1]|
| [4, 3, 2, 1]|
+---------------------------------+
'''52、to_json
将结构化的数据（如StructType结构的数据）转换为JSON格式的字符串，方便存储或者传输等操作。
df = df.withColumn("json_string", F.to_json("person_info"))
df.select("json_string").show()
'''
+--------------------+
| json_string|
+--------------------+
|{"firstname":"Jam...|
|{"firstname":"Mic...|
|{"firstname":"Rob...|
|{"firstname":"Mar...|
+--------------------+
'''53、from_json
将包含JSON格式字符串的列解析转换为相应的结构化数据类型（比如StructType等），便于后续进一步处理其中的字段数据。
from pyspark.sql.types import StructType, StructField, StringType, DateType
json_schema = StructType([
StructField("firstname", StringType(), True),
StructField("lastname", StringType(), True),
StructField("birthday", DateType(), True)
])
df.select(F.from_json("json_string", json_schema)).show()
'''
+----------------------+
|from_json(json_string)|
+----------------------+
| {James, Smith, 19...|
| {Michael, Rose, 1...|
| {Robert, Williams...|
| {Maria, Jones, 19...|
+----------------------+
'''54、udf
用于创建一个自定义函数，将其应用到DataFrame的每一行上。
def get_grade(score):
if score >= 90:
return "Grade A"
elif score >= 80:
return "Grade B"
elif score >= 70:
return "Grade C"
elif score >= 60:
return "Grade D"
else:
return "Grade E"
get_grade_udf = F.udf(get_grade, StringType())
df.select("score", get_grade_udf("score")).show()
'''
+-----+----------------+
|score|get_grade(score)|
+-----+----------------+
|60.86| Grade D|
| 80.0| Grade B|
| 91.0| Grade A|
| 59.5| Grade E|
+-----+----------------+
'''55、pandas_udf
pandas_udf是PySpark中提供的一种机制，允许使用pandas库的高效数据处理能力来定义用户自定义函数，相较于普通的udf，pandas_udf利用了pandas在向量化计算等方面的优势，在处理大数据量时往往能有更好的性能表现。
@F.pandas_udf(StringType())
def get_grade_pandas_udf(score_series: pd.Series) -> pd.Series:
result_series = score_series.apply(get_grade)
return result_series
df.select("score", get_grade_pandas_udf(F.col("score"))).show()
'''
+-----+---------------------------+
|score|get_grade_pandas_udf(score)|
+-----+---------------------------+
|60.86| Grade D|
| 80.0| Grade B|
| 91.0| Grade A|
| 59.5| Grade E|
+-----+---------------------------+
'''56、row_number
用于分配一个唯一的序号给 DataFrame 中的每一行，通常在窗口函数的上下文中使用。
from pyspark.sql import Window
windowSpec = Window.partitionBy("country").orderBy(F.desc("score"))
df = df.union(df.limit(1))
df.select("country", "score", F.row_number().over(windowSpec).alias("rn")).sort("country","rn").show()
'''
+-------+-----+---+
|country|score| rn|
+-------+-----+---+
| NULL| 91.0| 1|
| USA| 80.0| 1|
| USA|60.86| 2|
| USA|60.86| 3|
| USA| 59.5| 4|
+-------+-----+---+
'''57、rank
与row_number()类似，也是用于排名，但在遇到相同值时会分配相同的排名，并且下一个排名会出现 “空位”，即排名间断。
df.select("country", "score", F.rank().over(windowSpec).alias("rank")).sort("country","rank").show()
'''
+-------+-----+----+
|country|score|rank|
+-------+-----+----+
| NULL| 91.0| 1|
| USA| 80.0| 1|
| USA|60.86| 2|
| USA|60.86| 2|
| USA| 59.5| 4|
+-------+-----+----+
'''58、dense_rank
同样用于排名，在遇到相同值时分配相同排名，不过下一个排名是连续的，不会出现 “空位”。
df.select("country", "score", F.dense_rank().over(windowSpec).alias("dense_rank")).sort("country","dense_rank").show()
'''
+-------+-----+----------+
|country|score|dense_rank|
+-------+-----+----------+
| NULL| 91.0| 1|
| USA| 80.0| 1|
| USA|60.86| 2|
| USA|60.86| 2|
| USA| 59.5| 3|
+-------+-----+----------+
'''59、stddev
计算指定列数值的总体标准差，可用于分析数据的离散程度。
df.select(F.stddev("score")).collect()[0][0]
'''
14.29461017306873
'''60、var_samp
用于计算指定列数据的样本方差，反映数据的离散情况。另外var_pop用于计算总体方差。
df.select(F.var_samp("score")).collect()[0][0]
'''
204.33588000000003
'''二、总结
pyspark.sql.functions中的这些函数为用户在数据处理、分析和转换等方面提供了丰富的工具，能够满足各种复杂的数据处理需求，熟练掌握这些函数将大大提高在 PySpark 环境下处理大数据的效率和能力。无论是简单的数据清洗还是复杂的数据分析任务，都可以从中找到合适的函数来完成。
原文地址：https://blog.csdn.net/weixin_44458771/article/details/143891101
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！