PySpark3：pyspark.sql.functions常见的60个函数

目录

一、常见的60个函数

1、col

2、lit

3、sum

4、avg/mean

5、count

6、max

7、min

8、concat

9、substring

10、lower

11、upper

12、trim

13、ltrim

14、rtrim

15、split

16、explode

17、collect_list

18、collect_set

19、asc

20、desc

21、when

22、to_date

23、current_date

24、datediff

25、date_add

26、date_sub

27、year

28、month

29、day

30、cast

31、round

32、ceil

34、coalesce

35、isnull

36、isnotnull

37、like

38、rlike

39、size

40、array_contains

41、element_at

42、array_join

43、struct

44、expr

45、create_map

46、map_keys

47、map_values

48、translate

49、regexp_replace

50、flatten

51、sort_array

52、to_json

53、from_json

54、udf

55、pandas_udf

56、row_number

57、rank

58、dense_rank

59、stddev

60、var_samp

二、总结

---

一、常见的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 环境下处理大数据的效率和能力。无论是简单的数据清洗还是复杂的数据分析任务，都可以从中找到合适的函数来完成。