PySpark之SparkSQL基本操作

最新推荐文章于 2025-03-17 19:41:51 发布
最新推荐文章于 2025-03-17 19:41:51 发布
阅读量3.9k 收藏 35
点赞数 5
分类专栏： # PySpark 文章标签： 数据库 大数据 sql pyspark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35154281/article/details/116455509
版权

SparkSQL

DataFrame的优点：

  • DataFrame的推出，让Spark具备了处理大规模结构化数据的能力，不仅比原有的RDD转化方式更加简单易用，而且获得了更高的计算性能
  • Spark能够轻松实现从MySQL到DataFrame的转化，并且支持SQL查询

DataFrame和RDD的区别:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nlGztlnH-1620287012285)(./imgs/dataframe.png)]

  • RDD是分布式的Java对象的集合，但是，对象内部结构对于RDD而言却是不可知的
  • DataFrame是一种以RDD为基础的分布式数据集，提供了详细的结构信息
import findspark
findspark.init()
from pyspark.sql import SparkSession
from pyspark.sql import Row
from pyspark.sql import functions as fn
import os


# 创建SparkSession实现其对数据加载、转换、处理等功能
spark = SparkSession.builder.appName("test").getOrCreate()
sc = spark.sparkContext
ROOT_PATH = "file://" + os.getcwd()

RDD与DataFrame互相转换

# 创建DataFrame
l = [('Ankit',25),('Jalfaizy',22),('saurabh',20),('Bala',26)]
rdd = sc.parallelize(l)

# 加入键值对，即为数据加入列名
people =rdd.map(lambda x:Row(name = x[0], age = int(x[1])))  
people.collect()

[Row(name='Ankit', age=25),
 Row(name='Jalfaizy', age=22),
 Row(name='saurabh', age=20),
 Row(name='Bala', age=26)]

# 使用对象的集合，需要使用对象调用属性
row = Row(name="Alice", age=11)
row.name

'Alice'

schemapeople = spark.createDataFrame(people)
schemapeople.show()

+--------+---+
|    name|age|
+--------+---+
|   Ankit| 25|
|Jalfaizy| 22|
| saurabh| 20|
|    Bala| 26|
+--------+---+

# 创建临时表，使用SQL语句进行查询
schemapeople.createOrReplaceTempView("person")
spark.sql("select * from person")

DataFrame[name: string, age: bigint]

schemapeople.printSchema()

root
 |-- name: string (nullable = true)
 |-- age: long (nullable = true)

# DateFrame转换为RDD格式数据
schemapeople.rdd.collect()

[Row(name='Ankit', age=25),
 Row(name='Jalfaizy', age=22),
 Row(name='saurabh', age=20),
 Row(name='Bala', age=26)]

SparkSQL基本操作

CSV格式文件处理

# 读csv格式文件
# 方法一
# df = spark.read.format("csv").option("header","true").load("./data/iris.csv")
# 方法二：
df = spark.read.csv(ROOT_PATH + "/data/iris.csv", header=True)
df.show(5)

+------------+-----------+------------+-----------+-------+
|sepal_length|sepal_width|petal_length|petal_width|species|
+------------+-----------+------------+-----------+-------+
|         5.1|        3.5|         1.4|        0.2| setosa|
|         4.9|        3.0|         1.4|        0.2| setosa|
|         4.7|        3.2|         1.3|        0.2| setosa|
|         4.6|        3.1|         1.5|        0.2| setosa|
|         5.0|        3.6|         1.4|        0.2| setosa|
+------------+-----------+------------+-----------+-------+
only showing top 5 rows

# 打印模式信息
df.printSchema()

root
 |-- sepal_length: string (nullable = true)
 |-- sepal_width: string (nullable = true)
 |-- petal_length: string (nullable = true)
 |-- petal_width: string (nullable = true)
 |-- species: string (nullable = true)

# 列名
df.columns

['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'species']

# 总数据
df.count()

150

# 默认删除列，传入为可变参数
df.drop(*["species", "sepal_width"]).show(5)

+------------+------------+-----------+
|sepal_length|petal_length|petal_width|
+------------+------------+-----------+
|         5.1|         1.4|        0.2|
|         4.9|         1.4|        0.2|
|         4.7|         1.3|        0.2|
|         4.6|         1.5|        0.2|
|         5.0|         1.4|        0.2|
+------------+------------+-----------+
only showing top 5 rows

# 描述信息
df.describe().show()

+-------+------------------+-------------------+------------------+------------------+---------+
|summary|      sepal_length|        sepal_width|      petal_length|       petal_width|  species|
+-------+------------------+-------------------+------------------+------------------+---------+
|  count|               150|                150|               150|               150|      150|
|   mean| 5.843333333333335|  3.057333333333334|3.7580000000000027| 1.199333333333334|     null|
| stddev|0.8280661279778637|0.43586628493669793|1.7652982332594662|0.7622376689603467|     null|
|    min|               4.3|                2.0|               1.0|               0.1|   setosa|
|    max|               7.9|                4.4|               6.9|               2.5|virginica|
+-------+------------------+-------------------+------------------+------------------+---------+

# df.describe(*cols)
df.describe("petal_length").show()

+-------+------------------+
|summary|      petal_length|
+-------+------------------+
|  count|               150|
|   mean|3.7580000000000027|
| stddev|1.7652982332594662|
|    min|               1.0|
|    max|               6.9|
+-------+------------------+

# 选取指定列数据 以ROW类型数据格式进行数据存储
df.select("*").collect()[:3]

[Row(sepal_length='5.1', sepal_width='3.5', petal_length='1.4', petal_width='0.2', species='setosa'),
 Row(sepal_length='4.9', sepal_width='3.0', petal_length='1.4', petal_width='0.2', species='setosa'),
 Row(sepal_length='4.7', sepal_width='3.2', petal_length='1.3', petal_width='0.2', species='setosa')]

#  选几列数据
df.select(*["sepal_width", "sepal_length"]).show(5)

+-----------+------------+
|sepal_width|sepal_length|
+-----------+------------+
|        3.5|         5.1|
|        3.0|         4.9|
|        3.2|         4.7|
|        3.1|         4.6|
|        3.6|         5.0|
+-----------+------------+
only showing top 5 rows

# 显著分析
df.select(["species"]).distinct().show()

+----------+
|   species|
+----------+
| virginica|
|versicolor|
|    setosa|
+----------+

# 常用聚合函数
# avg(), count(), countDistinct(), first(), kurtosis(),
# max(), mean(), min(), skewness(), stddev(), stddev_pop(),
# stddev_samp(), sum(), sumDistinct(), var_pop(), var_samp() and variance()

# 注意：同一列数据只能够统计一次
df.groupBy("species").agg({"sepal_length":"mean", "sepal_width":"max" , "sepal_length":"variance"}).show()

+----------+----------------+----------------------+
|   species|max(sepal_width)|variance(sepal_length)|
+----------+----------------+----------------------+
| virginica|             3.8|    0.4043428571428571|
|versicolor|             3.4|    0.2664326530612246|
|    setosa|             4.4|   0.12424897959183674|
+----------+----------------+----------------------+

# fn 同一列数据可以统计多次,列名不同,聚合类型相同
df.agg(fn.count("sepal_length").alias("sepal_length_count"), fn.mean("sepal_width"), fn.max("sepal_width"), fn.countDistinct("species")).show()

+------------------+------------------+----------------+--------------+
|sepal_length_count|  avg(sepal_width)|max(sepal_width)|count(species)|
+------------------+------------------+----------------+--------------+
|               150|3.0573333333333337|             4.4|             3|
+------------------+------------------+----------------+--------------+

# 拆分数据集
train, val = df.randomSplit([0.7, 0.3], seed=0)

# 70%做训练集
train.count()/df.count()

0.7266666666666667

# 查看样本分配情况
train.select("species").distinct().show()

+----------+
|   species|
+----------+
| virginica|
|versicolor|
|    setosa|
+----------+

# 可以转为pandas数据处理
val.select("species").distinct().toPandas()
species
0virginica
1versicolor
2setosa
# 做减法，进行比较
val.select("species").subtract(train.select("species")).show()

+-------+
|species|
+-------+
+-------+

# 采样数据集
sample_data = df.sample(False, fraction = 0.1, seed = 3)
sample_data.count()

13

# 交叉表,共现频率
df.crosstab("species", "sepal_width").toPandas()
species_sepal_width2.02.22.32.42.52.62.72.82.9...3.43.53.63.73.83.94.04.14.24.4
0virginica010042482...2010200000
1setosa001000001...9633421111
2versicolor123343567...1000000000

3 rows × 24 columns

trainDF.select('species').subtract(testDF.select('species')).distinct().rdd.map(lambda x:[0]).collect()

[[0]]

# 使用临时表进行简单的SQL查询
trainDF.createOrReplaceTempView("train_table")
# 返回一个DateFrame
spark.sql("select petal_length from train_table where petal_length > 1.5").show(5)

+------------+
|petal_length|
+------------+
|         1.6|
|         1.6|
|         1.6|
|         1.9|
|         3.3|
+------------+
only showing top 5 rows

# 必须写入全路径, 加上file://
# 方法一：
# trainDF.write.json((ROOT_PATH + "/data/trainDF.json")
# 方法二：
trainDF.write.format("json").save(ROOT_PATH + "/data/trainDF.json")

Json格式文件处理

Json文件会自动检测数据类型

jsonString = [
"""{ "id" : "01001", "city" : "AGAWAM",  "pop" : 15338, "state" : "MA" }""",
"""{ "id" : "01002", "city" : "CUSHMAN", "pop" : 36963, "state" : "MA" }"""
]
jsonString

['{ "id" : "01001", "city" : "AGAWAM",  "pop" : 15338, "state" : "MA" }',
 '{ "id" : "01002", "city" : "CUSHMAN", "pop" : 36963, "state" : "MA" }']

jsonRDD = sc.parallelize(jsonString)
jsonRDD.collect()

['{ "id" : "01001", "city" : "AGAWAM",  "pop" : 15338, "state" : "MA" }',
 '{ "id" : "01002", "city" : "CUSHMAN", "pop" : 36963, "state" : "MA" }']

jsonDF = spark.read.json(jsonRDD)
jsonDF.show()

+-------+-----+-----+-----+
|   city|   id|  pop|state|
+-------+-----+-----+-----+
| AGAWAM|01001|15338|   MA|
|CUSHMAN|01002|36963|   MA|
+-------+-----+-----+-----+

jsonDF.printSchema()  # 着重区别与csv的格式数据的读入格式类型

root
 |-- city: string (nullable = true)
 |-- id: string (nullable = true)
 |-- pop: long (nullable = true)
 |-- state: string (nullable = true)

jsonDF = spark.read.json(ROOT_PATH + "/data/province.json")
jsonDF.show(5)

+----+--------+------------+
|code|    name|provinceCode|
+----+--------+------------+
|1101|  市辖区|          11|
|1201|  市辖区|          12|
|1301|石家庄市|          13|
|1302|  唐山市|          13|
|1303|秦皇岛市|          13|
+----+--------+------------+
only showing top 5 rows

jsonDF.printSchema()

root
 |-- code: string (nullable = true)
 |-- name: string (nullable = true)
 |-- provinceCode: string (nullable = true)

jsonDF.describe().show()

+-------+-----------------+--------+------------------+
|summary|             code|    name|      provinceCode|
+-------+-----------------+--------+------------------+
|  count|              342|     342|               342|
|   mean|4046.502923976608|    null| 40.35672514619883|
| stddev|1492.861959917837|    null|14.898333817383897|
|    min|             1101|七台河市|                11|
|    max|             6590|  龙岩市|                65|
+-------+-----------------+--------+------------------+

jsonDF.count()

342

jsonDF.filter(jsonDF.code>1440).show(4)

+----+----------+------------+
|code|      name|provinceCode|
+----+----------+------------+
|1501|呼和浩特市|          15|
|1502|    包头市|          15|
|1503|    乌海市|          15|
|1504|    赤峰市|          15|
+----+----------+------------+
only showing top 4 rows

# 更改数据为指定的数据类型
jsonString = [
"""{ "id" : "01001", "city" : "AGAWAM",  "pop" : 15338, "state" : "MA" }""",
"""{ "id" : "01002", "city" : "CUSHMAN", "pop" : 36963, "state" : "MA" }"""
]

jsonRDD = sc.parallelize(jsonString)
jsonRDD.collect()

['{ "id" : "01001", "city" : "AGAWAM",  "pop" : 15338, "state" : "MA" }',
 '{ "id" : "01002", "city" : "CUSHMAN", "pop" : 36963, "state" : "MA" }']

from pyspark.sql.types import *

#定义结构类型（方法一）
#StructType：schema的整体结构，表示JSON的对象结构
#XXXStype:指的是某一列的数据类型
jsonSchema = StructType() \
  .add("id", StringType(),True) \
  .add("city", StringType()) \
  .add("pop" , LongType()) \
  .add("state",StringType())

reader = spark.read.schema(jsonSchema)
reader.json(jsonRDD).show()

+-----+-------+-----+-----+
|   id|   city|  pop|state|
+-----+-------+-----+-----+
|01001| AGAWAM|15338|   MA|
|01002|CUSHMAN|36963|   MA|
+-----+-------+-----+-----+

# 读取数据类型
reader.json(jsonRDD).printSchema()

root
 |-- id: string (nullable = true)
 |-- city: string (nullable = true)
 |-- pop: long (nullable = true)
 |-- state: string (nullable = true)

# 改变输入数据的类型（方法二）
scheme = StructType([StructField("id", StringType())
                     , StructField("city", StringType())
                     , StructField("pop", LongType())
                     , StructField("state", StringType())
                    ]
                   )
data1 = spark.read.json(jsonRDD, schema=scheme)
data1.show()

+-----+-------+-----+-----+
|   id|   city|  pop|state|
+-----+-------+-----+-----+
|01001| AGAWAM|15338|   MA|
|01002|CUSHMAN|36963|   MA|
+-----+-------+-----+-----+

data1.printSchema()

root
 |-- id: string (nullable = true)
 |-- city: string (nullable = true)
 |-- pop: long (nullable = true)
 |-- state: string (nullable = true)

数据清洗

去重

df = spark.createDataFrame([
    
    (1, 144.5, 5.9, 33, 'M'),
    (2, 167.2, 5.4, 45, 'M'),
    (3, 124.1, 5.2, 23, 'F'),
    (4, 144.5, 5.9, 33, 'M'),
    (5, 133.2, 5.7, 54, 'F'),
    (3, 124.1, 5.2, 23, 'F'),
    (5, 129.2, 5.3, 42, 'M'),]
    , ['id', 'weight', 'height', 'age', 'gender']
)

df.show()

+---+------+------+---+------+
| id|weight|height|age|gender|
+---+------+------+---+------+
|  1| 144.5|   5.9| 33|     M|
|  2| 167.2|   5.4| 45|     M|
|  3| 124.1|   5.2| 23|     F|
|  4| 144.5|   5.9| 33|     M|
|  5| 133.2|   5.7| 54|     F|
|  3| 124.1|   5.2| 23|     F|
|  5| 129.2|   5.3| 42|     M|
+---+------+------+---+------+

# 去重,默认消除相同的行(行元素相同), id=3（全部）
df.dropDuplicates().show()

+---+------+------+---+------+
| id|weight|height|age|gender|
+---+------+------+---+------+
|  5| 133.2|   5.7| 54|     F|
|  5| 129.2|   5.3| 42|     M|
|  1| 144.5|   5.9| 33|     M|
|  4| 144.5|   5.9| 33|     M|
|  2| 167.2|   5.4| 45|     M|
|  3| 124.1|   5.2| 23|     F|
+---+------+------+---+------+

# 删除无意义字段之外的其他其他字段的重复数据(部分，即部分子字段内重值进行删除, 例如id=1和id=4)
df3 = df.drop_duplicates(subset=[c for c in df.columns if c!="id"])
df3.show()

+---+------+------+---+------+
| id|weight|height|age|gender|
+---+------+------+---+------+
|  5| 133.2|   5.7| 54|     F|
|  1| 144.5|   5.9| 33|     M|
|  2| 167.2|   5.4| 45|     M|
|  3| 124.1|   5.2| 23|     F|
|  5| 129.2|   5.3| 42|     M|
+---+------+------+---+------+

# 聚合某些特定的值, alias重命名数据格式
df3.agg(fn.count("id").alias("id_count"), fn.countDistinct("id").alias("distinct_id_count")).show()

+--------+-----------------+
|id_count|distinct_id_count|
+--------+-----------------+
|       5|                4|
+--------+-----------------+

# 添加新的一列数据index索引值，随机没有重复的索引值
df3.withColumn("new_id", fn.monotonically_increasing_id()).show()

+---+------+------+---+------+-------------+
| id|weight|height|age|gender|       new_id|
+---+------+------+---+------+-------------+
|  5| 133.2|   5.7| 54|     F|  25769803776|
|  1| 144.5|   5.9| 33|     M| 171798691840|
|  2| 167.2|   5.4| 45|     M| 592705486848|
|  3| 124.1|   5.2| 23|     F|1236950581248|
|  5| 129.2|   5.3| 42|     M|1365799600128|
+---+------+------+---+------+-------------+

缺失值处理

df_miss = spark.createDataFrame([
    (1, 143.5, 5.6, 28,'M', 100000),
    (2, 167.2, 5.4, 45,'M', None),
    (3, None , 5.2, None, None, None),
    (4, 144.5, 5.9, 33, 'M', None),
    (5, 133.2, 5.7, 54, 'F', None),
    (6, 124.1, 5.2, None, 'F', None),
    (7, 129.2, 5.3, 42, 'M', 76000),]
    , ['id', 'weight', 'height', 'age', 'gender', 'income']
)

df_miss.show()

+---+------+------+----+------+------+
| id|weight|height| age|gender|income|
+---+------+------+----+------+------+
|  1| 143.5|   5.6|  28|     M|100000|
|  2| 167.2|   5.4|  45|     M|  null|
|  3|  null|   5.2|null|  null|  null|
|  4| 144.5|   5.9|  33|     M|  null|
|  5| 133.2|   5.7|  54|     F|  null|
|  6| 124.1|   5.2|null|     F|  null|
|  7| 129.2|   5.3|  42|     M| 76000|
+---+------+------+----+------+------+

# 统计每一行的缺失值情况,转为rdd数据格式后，执行transformation操作, sum只对True进行统计
df_miss.rdd.map(lambda row:(row["id"], sum(c==None for c in row))).collect()

[(1, 0), (2, 1), (3, 4), (4, 1), (5, 1), (6, 2), (7, 0)]

# 统计列缺失情况
df_miss.agg(*[(1-(fn.count(c)/fn.count("*"))).alias(c+"_missing") for c in df_miss.columns]).show()

+----------+------------------+--------------+------------------+------------------+------------------+
|id_missing|    weight_missing|height_missing|       age_missing|    gender_missing|    income_missing|
+----------+------------------+--------------+------------------+------------------+------------------+
|       0.0|0.1428571428571429|           0.0|0.2857142857142857|0.1428571428571429|0.7142857142857143|
+----------+------------------+--------------+------------------+------------------+------------------+

# "*"表示统计所有的数据
df_miss.agg(fn.count("*")).show()

+--------+
|count(1)|
+--------+
|       7|
+--------+

# 删除缺失值严重的列
df_miss1 = df_miss.select([c for c in df_miss.columns if c!="income"])
df_miss1.show()

+---+------+------+----+------+
| id|weight|height| age|gender|
+---+------+------+----+------+
|  1| 143.5|   5.6|  28|     M|
|  2| 167.2|   5.4|  45|     M|
|  3|  null|   5.2|null|  null|
|  4| 144.5|   5.9|  33|     M|
|  5| 133.2|   5.7|  54|     F|
|  6| 124.1|   5.2|null|     F|
|  7| 129.2|   5.3|  42|     M|
+---+------+------+----+------+

# 删除缺存在值超过指定阈值的行数据，只要有超过thresh
(df_miss1.dropna(thresh=3).show(), df_miss1.dropna(thresh=5).show())

+---+------+------+----+------+
| id|weight|height| age|gender|
+---+------+------+----+------+
|  1| 143.5|   5.6|  28|     M|
|  2| 167.2|   5.4|  45|     M|
|  4| 144.5|   5.9|  33|     M|
|  5| 133.2|   5.7|  54|     F|
|  6| 124.1|   5.2|null|     F|
|  7| 129.2|   5.3|  42|     M|
+---+------+------+----+------+

+---+------+------+---+------+
| id|weight|height|age|gender|
+---+------+------+---+------+
|  1| 143.5|   5.6| 28|     M|
|  2| 167.2|   5.4| 45|     M|
|  4| 144.5|   5.9| 33|     M|
|  5| 133.2|   5.7| 54|     F|
|  7| 129.2|   5.3| 42|     M|
+---+------+------+---+------+

# 指定字段进行填充指定值
df_miss.show(), df_miss.fillna({"weight":150, "age":18, "gender":"sex", "income":6868}).show()

+---+------+------+----+------+------+
| id|weight|height| age|gender|income|
+---+------+------+----+------+------+
|  1| 143.5|   5.6|  28|     M|100000|
|  2| 167.2|   5.4|  45|     M|  null|
|  3|  null|   5.2|null|  null|  null|
|  4| 144.5|   5.9|  33|     M|  null|
|  5| 133.2|   5.7|  54|     F|  null|
|  6| 124.1|   5.2|null|     F|  null|
|  7| 129.2|   5.3|  42|     M| 76000|
+---+------+------+----+------+------+

+---+------+------+---+------+------+
| id|weight|height|age|gender|income|
+---+------+------+---+------+------+
|  1| 143.5|   5.6| 28|     M|100000|
|  2| 167.2|   5.4| 45|     M|  6868|
|  3| 150.0|   5.2| 18|   sex|  6868|
|  4| 144.5|   5.9| 33|     M|  6868|
|  5| 133.2|   5.7| 54|     F|  6868|
|  6| 124.1|   5.2| 18|     F|  6868|
|  7| 129.2|   5.3| 42|     M| 76000|
+---+------+------+---+------+------+

# 使用均值进行填补.
# - 'records' : list like
# [{column -> value}, ... , {column -> value}]

bb = df_miss1.agg(*[fn.mean(c).alias(c) for c in df_miss1.columns if c!="gender"]).toPandas()
bb.to_dict("recoder")

[{'id': 4.0,
  'weight': 140.28333333333333,
  'height': 5.471428571428572,
  'age': 40.4}]

miss_fill = df_miss1.agg(*[fn.mean(c).alias(c) for c in df_miss1.columns if c!="gender"]).toPandas().to_dict("records")[0]
miss_fill["gender"] = "M"
miss_fill

{'id': 4.0,
 'weight': 140.28333333333333,
 'height': 5.471428571428572,
 'age': 40.4,
 'gender': 'M'}

# 使用字典对指定列数据进行缺失值填补
df_miss1.fillna(miss_fill).show()

+---+------------------+------+---+------+
| id|            weight|height|age|gender|
+---+------------------+------+---+------+
|  1|             143.5|   5.6| 28|     M|
|  2|             167.2|   5.4| 45|     M|
|  3|140.28333333333333|   5.2| 40|     M|
|  4|             144.5|   5.9| 33|     M|
|  5|             133.2|   5.7| 54|     F|
|  6|             124.1|   5.2| 40|     F|
|  7|             129.2|   5.3| 42|     M|
+---+------------------+------+---+------+

异常值处理

  • 异常值：不属于正常的值 包含：缺失值，超过正常范围内的较大值或较小值分位数去极值
  • 中位数绝对偏差去极值
  • 正态分布去极值

上述三种操作的核心都是：通过原始数据设定一个正常的范围，超过此范围的就是一个异常值

知识点：四分位数(处理异常值)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-civeic3I-1620287012290)(./imgs/四分位点.gif)]

一般，数据集中的最小值我们称之为下界，最大值称之为上界。
计算四分位数之前，第一步需要先求中位数M，
下四分位数Q1=数据集中所有数值由小到大排列后第25%的数字
上四分位数Q3=数据集中所有数值由小到大排列后第75%的数字
四分位数间距： I Q R = Q 3 − Q 1 IQR = Q3 - Q1 IQR=Q3−Q1
下界（Min）： Q 1 − 1.5 ∗ I Q R Q1 - 1.5*IQR Q1−1.5∗IQR
上界(Max)： Q 3 + 1.5 ∗ I Q R Q3 + 1.5*IQR Q3+1.5∗IQR

df_outliers = spark.createDataFrame([
    (1, 143.5, 5.3, 28),
    (2, 154.2, 5.5, 45),
    (3, 342.3, 5.1, 99),
    (4, 144.5, 5.5, 33),
    (5, 133.2, 5.4, 54),
    (6, 124.1, 5.1, 21),
    (7, 129.2, 5.3, 42),
    ]
    , ['id', 'weight', 'height', 'age']
)

df_outliers.show()

+---+------+------+---+
| id|weight|height|age|
+---+------+------+---+
|  1| 143.5|   5.3| 28|
|  2| 154.2|   5.5| 45|
|  3| 342.3|   5.1| 99|
|  4| 144.5|   5.5| 33|
|  5| 133.2|   5.4| 54|
|  6| 124.1|   5.1| 21|
|  7| 129.2|   5.3| 42|
+---+------+------+---+

# 计算数值型数据的四分位数据点
cols = ["weight", "height", "age"]
bounds = {}

for col in cols:
    # 0.25, 0.75 分位数
    quantiles = df_outliers.approxQuantile(col, [0.25, 0.75], 0)
    
    # 极差
    IQR = quantiles[1] - quantiles[0]
    bounds[col] = [quantiles[0] - 1.5*IQR, quantiles[1] + 1.5*IQR]

bounds

{'weight': [91.69999999999999, 191.7],
 'height': [4.499999999999999, 6.1000000000000005],
 'age': [-11.0, 93.0]}

outliers = df_outliers.select(*['id'] + [((df_outliers[c] < bounds[c][0]) | (df_outliers[c] > bounds[c][1])).alias(c + '_o') for c in cols])
outliers.show()

+---+--------+--------+-----+
| id|weight_o|height_o|age_o|
+---+--------+--------+-----+
|  7|   false|   false|false|
|  6|   false|   false|false|
|  5|   false|   false|false|
|  1|   false|   false|false|
|  3|    true|   false| true|
|  2|   false|   false|false|
|  4|   false|   false|false|
+---+--------+--------+-----+

df_outliers.select("id", "weight").show()

+---+------+
| id|weight|
+---+------+
|  1| 143.5|
|  2| 154.2|
|  3| 342.3|
|  4| 144.5|
|  5| 133.2|
|  6| 124.1|
|  7| 129.2|
+---+------+

df_outliers = df_outliers.join(outliers, on="id")
df_outliers.show()

+---+------+------+---+--------+--------+-----+
| id|weight|height|age|weight_o|height_o|age_o|
+---+------+------+---+--------+--------+-----+
|  7| 129.2|   5.3| 42|   false|   false|false|
|  6| 124.1|   5.1| 21|   false|   false|false|
|  5| 133.2|   5.4| 54|   false|   false|false|
|  1| 143.5|   5.3| 28|   false|   false|false|
|  3| 342.3|   5.1| 99|    true|   false| true|
|  2| 154.2|   5.5| 45|   false|   false|false|
|  4| 144.5|   5.5| 33|   false|   false|false|
+---+------+------+---+--------+--------+-----+

df_outliers.filter("weight_o").select("id", "weight").show()

+---+------+
| id|weight|
+---+------+
|  3| 342.3|
+---+------+

df_outliers.filter("age_o").select("id", "age").show()

+---+---+
| id|age|
+---+---+
|  3| 99|
+---+---+

参考

基于PYSPARK创建DATAFRAME的几种方法
四分位数间距_四分位数计算公式_四分位数函数

PySpark-Spark SQL基本介绍
denglh525693的博客
01-07 2689
Spark SQL是Spark多种组件中其中一个,主要是用于处理大规模的结构化数据,本文阐述了Spark SQL的特点以及对比了Spark SQL和Hive SQL的异同,详细介绍了Spark SQL的数据结构DataFrame,包括DataFrame的三种构建方式,通过RDD构建DataFrame,通过内部初始化数据得到DataFrame,通过读取外部文件得到DataFrame
PySpark 小白教程 (二) PySpark SQL 简介
weixin_41046245的博客
06-05 1155
PySpark 是 Apache Spark 的 Python API，允许通过 Python 脚本进行大数据处理和分析。PySpark SQL 是 PySpark 的一个模块，用于处理结构化数据。它提供了与 SQL 语法相似的 DataFrame API，使数据工程师和数据科学家能够轻松地执行各种数据操作。
pyspark Spark SQL
weixin_42529756的博客
02-28 911
1、Spark SQL 概述 Spark SQL概念 Spark SQL is Apache Spark’s module for working with structured data. 它是spark中用于处理结构化数据的一个模块 Spark SQL历史 Hive是目前大数据领域，事实上的数据仓库标准。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mPnE8yAy-1614524559940)(pics/s9.png)] Shark：shark底层使用
pyspark详细讲解
最新发布
2401_89241757的博客
03-17 1001
pyspark教程讲解主讲，RDD数据输入，计算，输出（主讲），Hadoop依赖问题简述，map()运行问题简述
PySpark SQL 相关知识介绍
foochane
06-06 368
1 大数据简介 大数据是这个时代最热门的话题之一。但是什么是大数据呢?它描述了一个庞大的数据集，并且正在以惊人的速度增长。大数据除了体积(Volume)和速度(velocity)外，数据的多样性(variety)和准确性(veracity)也是大数据的一大特点。让我们详细讨论体积、速度、多样性和准确性。这些也被称为大数据的4V特征。 1.1 ...
PySpark基础 —— SparkSQL
qq_52421831的博客
10-18 4040
PySpark基础 —— SparkSQL
PySpark基础入门（7）：Spark SQL
WHY的博客
05-08 1650
SparkSQL 是Spark的一个模块, 用于处理海量结构化数据；PySpark使用DataFrame进行数据抽象，是一个二维表数据结构，适用于分布式集合
pyspark sparkSQL基本方法及用法
11-05
Pyspark中的Spark SQL是Apache Spark用于处理结构化数据的模块，它允许用户通过DataFrame API轻松地对SQL查询进行...5. **基本操作**: - `df.show()` 显示DataFrame的部分内容。 - `df.describe()` 提供统计摘要。
sparksql 基本操作
12-02
以下是 Spark SQL 的基本操作方法： 1. 创建 SparkSession 对象 ```python from pyspark.sql import SparkSession spark = SparkSession.builder.appName("SparkSQL").getOrCreate() ``` 2. 读取数据源并创建 ...
PySparkSQL 入门(概述、DataFrame操作)
u013076651的博客
02-27 1432
SparkSQL 是Spark的一个模块, 用于处理海量结构化数据第一、针对结构化数据处理，属于Spark框架一个部分第二、抽象数据结构：DataFrameDataFrame = RDD + Schema信息；第三、分布式SQL引擎，类似Hive框架从Hive框架继承而来，Hive中提供bin/hive交互式SQL命令行及HiveServer2服务，SparkSQL都可以；Spark SQL模块架构示意图如下。
PySpark学习指南：从环境搭建到SparkSQL与SparkStreaming
"09-SparkV1.2(PySpark)-LAPTOP-G48G0MSR.docx" 本文档详细介绍了如何学习和...通过这个课程，学员将能够全面掌握PySpark的使用，从基本的RDD操作到复杂的SparkSQL查询，再到实时流处理，最终能应用到实际项目中去。
PySpark之Spark SQL的使用《七》
热门推荐
wywinstonwy的专栏
05-26 1万+
Spark SQLis Apache Spark's module for working with structured data.
PySpark | SparkSQL函数 | SparkSQL运行流程
liujiesxs的博客
06-28 1397
SparkSQL函数定义，SparkSQL整合Hive
（二）PySpark3：SparkSQL编程
weixin_44458771的博客
03-07 2126
总的来说，Spark SQL是一个功能强大的工具，适合于处理大规模数据集和进行复杂的数据分析。Spark SQL能够访问多种数据源，包括本地数据集、HDFS、Hive、HBase等，并且通过集成类RDD、类Excel、类SQL的数据处理操作，增强了数据处理的易用性和多样性。
Spark SQL编程指南（Python）【转】
dianzhouyu2189的博客
05-14 522
转自：http://www.cnblogs.com/yurunmiao/p/4685310.html 前言 Spark SQL允许我们在Spark环境中使用SQL或者Hive SQL执行关系型查询。它的核心是一个特殊类型的Spark RDD：SchemaRDD。 SchemaRDD类似于传统关系型数据库的一张表，由两部分组成： Rows：数据行对象 Schem...
PySpark之SparkSQL的特点
feizuiku0116的博客
02-10 1436
一、SparkSQL的特点 一、融合性 SQL可以无缝集成在代码中，随时用SQL处理数据 二、统一数据访问 一套标准API可读写不同数据源 三、Hive兼容 可以使用SparkSQL直接计算并生成Hive数据表 四、标准化连接 支持标准化JDBC\OCBC连接，方便和各种数据库进行数据交互 ...
pyspark sql简单入门
窦永厚
09-28 1936
采用python开发spark sql简单入门 1.读取本地csv文件转换为DataFrame 2.DataFrame注册为spark sql临时表 3.spark sql()函数查询返回DataFrame数据，或者直接DataFrame API返回数据
PySpark大数据分析(7)：Spark SQL
唐犁的博客
05-25 379
UDF可以轻松实现复杂操作以及它们的反复使用。用户可以在dataframe的select()，withColumn()，以及SQL中的udf()调用Python中注册的自定义函数，简单来说就是对于复杂一些的处理，用户不需要在SQL中进行直接编程来实现，而是使用Python实现该功能，并作为一个UDF在SQL中调用。PySpark同时支持Spark SQL以及Hive的UDF。需要注意的是，由于对于Spark而言，UDF相当于一个黑盒，Spark内部对dataframe的优化无法应用在UDF上。因此UDF本身
pyspark系列5-Spark SQL介绍
只是甲的博客
04-29 5096
文章目录一.Spark SQL的概述1.1 Spark SQL 来源1.2 从代码看Spark SQL的特点1.3 从代码运行速度看来看Spark SQL二.Spark SQL数据抽象2.1 DataFrame2.2 Dataset三.Spark SQL 操作数据库3.1 Spark SQL操作Hive数据库3.1.1 Spark1版本使用方法3.1.2 Spark2版本使用方法3.2 Spark SQL操作MySQL数据库3.2.1 Spark1的写法3.2.2 Spark2的写法参考: 一.Spark
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值