pyspark数据处理之----全量查询select和条件查询filter

已于 2023-03-21 12:25:25 修改
阅读量1.1w 收藏 52
点赞数 3
分类专栏： Spark 文章标签： spark big data 大数据
于 2022-01-11 10:37:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41885239/article/details/122416047
版权

在spark中，对数据的查询和数据库是有点对齐的，有条件查询也有部分列查询

文章目录

头文件导入和测试数据创建

具体如何创建原始dataframe数据，请看上一篇博客（dataframe的8种创建方法）

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('increase delete change select').master('local').getOrCreate()

df = spark.createDataFrame([
    ['alex',1,2,'string1'],
    ['paul',11 ,12,'string2'],
    ['alex',21,22,'leon'],
    ['james',31,32,'traveler']],schema=('name string,a long, b long, c string'))

df.show()

+-----+---+---+--------+
| name|  a|  b|       c|
+-----+---+---+--------+
| alex|  1|  2| string1|
| paul| 11| 12| string2|
| alex| 21| 22|    leon|
|james| 31| 32|traveler|
+-----+---+---+--------+

条件查询

  对数据的条件查询其实是针对具体的列 进行操作的，所以可以认为每一次的条件查询，都是要把条件施加到具体的某一列上，比如 df.filter(df.age > 10), 这个大于10的条件筛选其实就是施加在具体的age列上的。

条件查询用filter，具体的格式如下：

  • df [‘筛选条件’]
  • df.filter (‘筛选条件’)
  • df.where (‘筛选条件’)

  filter和where二者的用法一样，所以二选一讲解即可

1.区间查询

这是我自己命名的的，我认为大于或者小于某个数都是在一个区间范围内，无外乎这个区间是有限还是无限。

1.1. 在区间查询上，通常最常规的当然是利用关系运算符进行查询（> , < , == ）
下图是筛选所有记录中，a列中大于20的数据记录。

分别用两种格式来演示

#这是利用关系运算符进行查询的，< 和 ==的查询类似
df.filter(df.a > 20).show()

+-----+---+---+--------+
| name|  a|  b|       c|
+-----+---+---+--------+
| alex| 21| 22|    leon|
|james| 31| 32|traveler|
+-----+---+---+--------+

df[df.a > 20].show()

+-----+---+---+--------+
| name|  a|  b|       c|
+-----+---+---+--------+
| alex| 21| 22|    leon|
|james| 31| 32|traveler|
+-----+---+---+--------+

1.2,between(lowerBound, upperBound)
查询最低值lowerBound到最高值upperBound之间的数据记录
下图是筛选所有记录中，a列中数据在10-30之间的数据记录

df.filter(df.a.between(10,30)).show()

+----+---+---+-------+
|name|  a|  b|      c|
+----+---+---+-------+
|paul| 11| 12|string2|
|alex| 21| 22|   leon|
+----+---+---+-------+

2.字符串的子串的包含查询

2.1 contains(other)
  查询某一列中包含子串other的数据记录,通常这个other是一个字符串
  下图是筛选所有记录中，c列值包含str的数据记录
  值得注意的是：这个作为一个字串，在实际的查询的字符串中，它可以是任何位置，比如有一个值是string1，这里contains的参数other如果是in，那他会在string1中每一个位置搜寻in，找到即可。

df.filter(df.c.contains('str')).show()

+----+---+---+-------+
|name|  a|  b|      c|
+----+---+---+-------+
|alex|  1|  2|string1|
|paul| 11| 12|string2|
+----+---+---+-------+

2.2 like(str)
  查询满足str条件的数据，通常这个str是一个由字符串和通配符组成的
  下图是筛选所有记录中，c列值以on结尾的数据记录
  值得注意是：这个on的位置是固定，必须是在尾部，因为前面有一个on的通配符，如果是on%，那on必须在开头，所以这个on的位置是由我们自己设定的，这点是和contains不同之处；当然如果你想在任何位置找on，则可以是%on%，关于通配符的一些使用，可以自行百度。

df.filter(df.c.like('%on')).show()

+----+---+---+----+
|name|  a|  b|   c|
+----+---+---+----+
|alex| 21| 22|leon|
+----+---+---+----+

2.3 startswith(other)
  查询数据是以other开头的数据记录
  下图是筛选所有记录中，c列值以str开头的数据记录
  注意：这里其实好比是contains和like的特殊形式

df.filter(df.c.startswith('str')).show()

+----+---+---+-------+
|name|  a|  b|      c|
+----+---+---+-------+
|alex|  1|  2|string1|
|paul| 11| 12|string2|
+----+---+---+-------+

2.4 endswith(other)
  查询数据是以other结尾的数据记录
  下图是筛选所有记录中，c列值以ing2结尾的数据记录
  注意：这里其实好比是contains和like的特殊形式

df.filter(df.c.endswith('ing2')).show()

+----+---+---+-------+
|name|  a|  b|      c|
+----+---+---+-------+
|paul| 11| 12|string2|
+----+---+---+-------+

2.5.isin(*cols)
  查询具体列中，包含在cols下的数据，通常这可以叫具体查询
  下图是筛选所有记录中，c列值为string1和Leon的数据记录

df.filter(df.c.isin(['string1','leon'])).show()

+----+---+---+-------+
|name|  a|  b|      c|
+----+---+---+-------+
|alex|  1|  2|string1|
|alex| 21| 22|   leon|
+----+---+---+-------+

3.空值查询

3.1.isNotNull（）
  列中非空值筛选
  下图是筛选所有记录中，a不为0的数据记录。

df.filter(df.a.isNotNull()).show()

+-----+---+---+--------+
| name|  a|  b|       c|
+-----+---+---+--------+
| alex|  1|  2| string1|
| paul| 11| 12| string2|
| alex| 21| 22|    leon|
|james| 31| 32|traveler|
+-----+---+---+--------+

3.2.isNull（）
  列中空值筛选
  下图是筛选所有记录中，a为0的数据记录。

df.filter(df.a.isNull()).show()

+----+---+---+---+
|name|  a|  b|  c|
+----+---+---+---+
+----+---+---+---+

部分列查询

具体格式如下:

  • df.select(要显示的列)
  • df[要显示的列]

由于这俩的效果是完全一样的，

1.select部分列查询

关于select怎么查，其实就是把想要的列往里丢就行，所以这里就讲解一下，这个往里丢丢列名该怎么写

1.1第一种查询，用’.'来表示列
  下图是查询a列和c列

df.select(df.a,df.c).show()

+---+--------+
|  a|       c|
+---+--------+
|  1| string1|
| 11| string2|
| 21|    leon|
| 31|traveler|
+---+--------+

1.2.第二种查询，用[]来表示列
  下图是查询a列和c列

df.select(df['a'],df['c']).show()

+---+--------+
|  a|       c|
+---+--------+
|  1| string1|
| 11| string2|
| 21|    leon|
| 31|traveler|
+---+--------+

1.2.第三种查询，用pyspark中的function中的col来制定列
  下图是查询a列和c列

from pyspark.sql import functions as F
df[F.col('a'),F.col('c')].show()

+---+--------+
|  a|       c|
+---+--------+
|  1| string1|
| 11| string2|
| 21|    leon|
| 31|traveler|
+---+--------+

2.[ ]部分列查询

同样的，对于这样的方式，你可以有三种写法：
第一种就是利用’.'来访问列，比如：df [ df.a,df.c ]
第二种就是利用[]来访问列，比如：df [ df[‘a’] , df[‘c’] ]
第三种就是利用名字来访问列，比如：df [ ‘a’,‘c’ ]
第三种就是利用col来访问列，比如：df [ F.col(‘a’),F.col(‘c’) ]
下图是查询a列和c列的部分演示

df[[df.a,df.c]].show()

+---+--------+
|  a|       c|
+---+--------+
|  1| string1|
| 11| string2|
| 21|    leon|
| 31|traveler|
+---+--------+

#3.全量查询的第三种表达
df['a','c'].show()

+---+--------+
|  a|       c|
+---+--------+
|  1| string1|
| 11| string2|
| 21|    leon|
| 31|traveler|
+---+--------+

3.部分列查询+条件筛选

  全量查询也可以加筛选条件，但是和条件查询的差异在于，它不会将不符合条件的值筛选掉，而是会将施加筛选条件的那一列二值化，不符合条件的为false，符合条件的为true

df.select(df.a,df.b> 20 ).show()

+---+--------+
|  a|(b > 20)|
+---+--------+
|  1|   false|
| 11|   false|
| 21|    true|
| 31|    true|
+---+--------+

  这里插入一点和查询无关的知识点（列名修改和类型转化）,因为从上面的查询结果看出，经过筛选之后，我们得到的b列因为施加了筛选条件后，列名改变了，如下图所示：
在这里插入图片描述
  但是有时候我们并不想改变名字，活着想改一个其他的名字，这时候就需要用到alias关键字，在alias里面写你想要起的列名就行。

df.select(df.a,(df.b> 20).alias('新名字') ).show()

+---+------+
|  a|新名字|
+---+------+
|  1| false|
| 11| false|
| 21|  true|
| 31|  true|
+---+------+

  这时候列名就被我们改变了，如果你想改回原来的列名“b”，依照葫芦画瓢就行。
  但是还有一个问题，可以看一下加工后的列的值，是bool值，但是如果你想改改为0，1的值，这就涉及到一个cast关键字，在cast中写下你想要转化的类型就行啦
下面是进行类型转换后对列名进行了重命名

df.select(df.a,(df.b> 20).cast('int').alias("w")).show()

+---+---+
|  a|  w|
+---+---+
|  1|  0|
| 11|  0|
| 21|  1|
| 31|  1|
+---+---+

全量查询+替换

  接着上面的说，上面的例子可以将符合条件的变为true，不符合的变为false，那具体的应用场景是什么呢？
我们还能做些什么呢？，我们可以进行批量改写，这时候就引出一个when…otherwise()
这个when的api是在functions下，若以需要进行额外的引入

下图是将b列中，大于20的改为888，否则就为999

from pyspark.sql import functions as F
df.select(df.a,F.when(df.b > 20, 888).otherwise(999)).show()

+---+----------------------------------------+
|  a|CASE WHEN (b > 20) THEN 888 ELSE 999 END|
+---+----------------------------------------+
|  1|                                     999|
| 11|                                     999|
| 21|                                     888|
| 31|                                     888|
+---+----------------------------------------+

下图是将b列中，大于20的改为888，小于10的改为666，否则就为999

df.select(df.a,F.when(df.b > 20, 888).when(df.b < 10,666).otherwise(999)).show()

+---+---------------------------------------------------------------+
|  a|CASE WHEN (b > 20) THEN 888 WHEN (b < 10) THEN 666 ELSE 999 END|
+---+---------------------------------------------------------------+
|  1|                                                            666|
| 11|                                                            999|
| 21|                                                            888|
| 31|                                                            888|
+---+---------------------------------------------------------------+

列名重命名

  从以上的几个例子发现施加条件筛选后的列名奇奇怪怪，很长，这显然不是我们想要的，这时候可以对其进行列名的修改，将其改为原来的列名 ，其实在上上小节已经讲过一点点了。

  • .alias(‘列名’)
  • .name(‘列名’)

下面举个例子：
  未改列名之前，列名很长

df.select(df.a,F.when(df.b > 20, 888).when(df.b < 10,666).otherwise(999)).show()

+---+---------------------------------------------------------------+
|  a|CASE WHEN (b > 20) THEN 888 WHEN (b < 10) THEN 666 ELSE 999 END|
+---+---------------------------------------------------------------+
|  1|                                                            666|
| 11|                                                            999|
| 21|                                                            888|
| 31|                                                            888|
+---+---------------------------------------------------------------+

修改列名后

df.select(df.a,F.when(df.b > 20, 888).when(df.b < 10,666).otherwise(999).alias('b')).show()

+---+---+
|  a|  b|
+---+---+
|  1|666|
| 11|999|
| 21|888|
| 31|888|
+---+---+

df.select(df.a,F.when(df.b > 20, 888).when(df.b < 10,666).otherwise(999).name('b')).show()

+---+---+
|  a|  b|
+---+---+
|  1|666|
| 11|999|
| 21|888|
| 31|888|
+---+---+

数据类型修改

有时候想对数据进行类型转换，比如将某一列的bingint型转为string类型这样，可以有两种方法。

  • 一种方法是astype（）；
  • 一种方法是case（）；

二者的用法是完全一致的

df

DataFrame[name: string, a: bigint, b: bigint, c: string]

df[df.a,df.b.astype('string'),df.c]

DataFrame[a: bigint, b: string, c: string]

df[df.a.cast('string'),df.b.astype('string'),df.c]

DataFrame[a: string, b: string, c: string]
远方的旅行者
关注
  • 3
    点赞
  • 踩
  • 52
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
mybatis-plus QueryWrapper自定义查询条件的实现
08-24
主要介绍了mybatis-plus QueryWrapper自定义查询条件的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
pyspark学习42-43：删除重复行、删除有空值的行、填充空值、filter过滤数据
qq_39954916的博客
10-02 6166
对应笔记3.3，视频42-43 1、删除重复行 df = spark.read.csv('/sql/customers.csv',header=True) >>> from pyspark.sql import Row >>> df = sc.parallelize([ ... Row(name='regan', age=27, height=170), ... Row(name='regan', age=27, height=170), ... Row(name=
PySpark数据分析基础：PySpark Pandas创建、转换、查询、转置、排序操作详解_pyspark
最新发布
2401_84182222的博客
04-28 382
时至如今Pandas仍然是十分火热的基于Python的数据分析工具，与numpy、matplotlib称为数据分析三大巨头，是学习Python数据分析的必经之路。Pandas提供了大量能使我们快速便捷地处理数据的函数和方法，它是使Python成为强大而高效的数据分析环境的重要因素之一。因此我们做分布式数据分析也同样离不开Pandas的支持。
PySpark基础入门（7）：Spark SQL
WHY的博客
05-08 1420
SparkSQL 是Spark的一个模块, 用于处理海量结构化数据；PySpark使用DataFrame进行数据抽象，是一个二维表数据结构，适用于分布式集合
Python---pyspark：RDD中数据计算成员方法（map方法、flatMap方法、reduceByKey方法、filter方法、distinct方法、sortBy方法）
weixin_43961909的博客
04-28 1148
快速编写，函数表示用来决定排序的依据，可以控制升序或降序，全局排序需要设置分区数为1。reduceByKey中接受的函数，只负责聚合，不理会分组。的算子，可以通过链式调用的方式多次调用算子。接受一个处理函数，对数据进行两两计算。接受一个处理函数，可用lambda。接受一个处理函数，可用lambda。内的元素逐个处理，并返回一个新的。中，过滤想要的数据进行保留。表达式快速编写，对RDD。多出，解除一层嵌套的功能。map算子（成员方法）快速编写，函数对RDD。distinct算子。接收一个处理函数，可用。
pyspark filter过滤元素代码示例
学亮编程手记
10-22 2802
from pyspark import SparkContext sc = SparkContext("local", "count app") words = sc.parallelize( ["scala", "java", "hadoop", "spark", "akka", "spark vs hadoop", "pyspark", "pyspark and spark" ]) # 统计元素个数 # coun.
PySpark简单使用(四)——filter、disctinct、sortBy 方法的使用
qq_42120843的博客
06-13 595
【代码】PySpark简单使用(四)——filter、disctinct、sortBy 方法的使用。
【Python】PySpark 数据计算 ④ ( RDD#filter 方法 - 过滤 RDD 中的元素 | RDD#distinct 方法 - 对 RDD 中的元素去重 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
08-02 1515
一、RDD#filter 方法 1、RDD#filter 方法简介 2、RDD#filter 函数语法 3、代码示例 - RDD#filter 方法示例 二、RDD#distinct 方法 1、RDD#distinct 方法简介 2、代码示例 - RDD#distinct 方法示例
pyspark 查询数据filter、where；head展示数据全
weixin_42357472的博客
03-03 2056
filter import pyspark.sql.functions as F data.filter(F.col("aid") == "32378").show() where data.where(F.col("aid").isNotNull())
spark2.1：使用df.select(when(a===b,1).otherwise(0))替换(case when a==b then 1 else 0 end)
weixin_34234823的博客
03-07 1087
最近工作中把一些sql.sh脚本执行hive的语句升级为spark2.1版本，其中遇到将case when 替换为scala操作df的方式实现的问题： 代码数据： scala&gt; import org.apache.spark.sql.functions._ import org.apache.spark.sql.functions._ scala&gt; im...
数据库的查询-分组.ppt
11-15
"数据库查询-分组" 数据库查询-分组是数据库查询语言中的一种重要的查询方式。它允许用户根据不同的条件对数据进行分组和聚合...它可以根据不同的条件对数据进行分组和聚合操作，并且可以对查询结果进行排序和筛选。
django-filter和普通查询的例子
09-18
总的来说，Django 普通查询和 `django-filter` 都是数据查询的重要工具，它们各自适用于不同的场景。普通查询简单直接，适合基础的数据库操作，而 `django-filter` 则为复杂、交互式的查询提供了便利，尤其在构建...
mybatis-plus分页查询的实现示例
09-07
然后在 Service 或 Controller 层调用 `UserMapper` 的 `selectPage()` 方法，传入 `Page` 对象和查询条件： ```java IPage<User> userPage = userMapper.selectPage(page, new QueryWrapper()); ``` `Query...
percona-toolkit之pt-kill 杀掉mysql查询或连接的方法
09-10
主要应用场景是监控和处理那些执行时间过长的`SELECT`操作，以防止它们阻塞其他关键的SQL执行。 使用`pt-kill`的基本命令格式如下： ```bash pt-kill [选项] ... ``` 例如，以下命令将创建一个日志表`testdb.kill...
SparkSQL 选择列
weixin_46300771的博客
02-28 1647
Spark SQL中对列的选择
pyspark数据类型转换-withColumn,select,selectExpr,sql四种方式
Jimmy and Zoey
12-08 9321
pyspark中数据类型转换共有4种方式：withColumn, select, selectExpr,sql 介绍以上方法前，我们要知道dataframe中共有哪些数据类型。每一个类型必须是DataType类的子类，包括 ArrayType, BinaryType, BooleanType, CalendarIntervalType, DateType, HiveStringType, MapType, NullType, NumericType, ObjectType, StringType, Stru
Spark中常用函数
weixin_57551874的博客
06-15 1852
1. filter过滤函数 df.filter(df.列名==值) 或者 df.filter("列名==值") 中间可以使用(或操作|) (与操作&) 2. union函数 df.union(df1) 可进行行合并的操作，df与df1的列名相同 3. 本地集合求并集 totalset = set1 | set2 set1=set(pandas['列名']) 4. pandas df 选择数据 df.iat[i,0] 选择行为i，列为0的数据 5. pyspark df选
Pyspark 读 DataFrame 的使用与基本操作
热门推荐
weixin_41888257的博客
12-20 1万+
一、安装 基于 mac 操作系统 安装 jdk jdk 下载地址 安装 pyspark pip install pyspark 二、基本操作 2.1 建立SparkSession对象 一切操作之前需要先建立一个SparkSession对象(运行Spark code的Entrance point,可以理解为交互部件)： 详见： pyspark.sql module from pyspark.sql import SparkSession spark = SparkSession.builder.ma
mybatis-plus 条件查询单条数据
05-22
使用 Mybatis-Plus 进行条件查询单条数据有多种方式，以下是其中两种常见的方式： 1. selectOne 使用 selectOne 方法查询单条数据，需要传入一个 Wrapper 对象作为查询条件： ```java User user = new User(); user.setId(1L); QueryWrapper<User> wrapper = new QueryWrapper<>(user); User result = userMapper.selectOne(wrapper); ``` 2. LambdaQueryWrapper 使用 LambdaQueryWrapper 对象可以更加方便地进行条件查询，同样也是通过 selectOne 方法查询单条数据： ```java LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>(); wrapper.eq(User::getId, 1L); User result = userMapper.selectOne(wrapper); ``` 这里的 LambdaQueryWrapper 通过调用 eq 方法指定查询条件，可以指定多个查询条件进行组合查询。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值