pyspark安装和使用

最新推荐文章于 2023-12-04 22:28:52 发布

最美不过你回眸

最新推荐文章于 2023-12-04 22:28:52 发布

阅读量2k

点赞数

分类专栏：老师笔记 spark

本文链接：https://blog.csdn.net/weixin_44768806/article/details/104800973

版权

老师笔记同时被 2 个专栏收录

12 篇文章 0 订阅

订阅专栏

spark

7 篇文章 0 订阅

订阅专栏

PySpark笔记

PySpark:Python on Spark
基于python语言,使用spark提供的pythonAPI库，进行spark应用程序的编程

==============================================================
一、搭建PySpark的环境
1.windows上进行pyspark环境配置
步骤：
-1.在windows上搭建python的环境(已搭建)
方式一：直接下载python安装包。
方式二：使用anaconda安装
-2.首先找到存放库的目录
进入cmd，输入python，回车
输入import sys
输入sys.path => 找到了
-3.将Spark的安装目录下的python目录下的lib中
pyspark.zip
py4j-0.10.4-src.zip
这两个把放在上面找到的site-packages里面
-4.放好之后，解压这两个压缩包，解压完之后，把这两个包删除

2.Linux上搭建PySpark环境（python的版本应该是3.6.5）
步骤：
	-1.检查：linux中python的版本
		在linux中输入python -V 回车
		看一下版本是多少。
		因为大家使用的centos的版本是7的版本，那么自带的python的版本应该是2.7.5，那么我们需要安装python3的版本，不需要写在自带的python2
	-2.安装python3 
		1.下载Python 3.6.5的包
			在线下载：
				可以直接在linux中执行一下命令
				wget https://www.python.org/ftp/python/3.6.5/Python-3.6.5.tgz
				如果同学发现，自己没有wget命令
				yum install -y wget
			离线安装:
				先从官网上下载包https://www.python.org/ftp/python/3.6.5/Python-3.6.5.tgz
				然后再把下载好的包上传到linux即可
		2.解压安装
			tar -zxvf Python-3.6.5.tgz -C /opt/cdh5.14.2/modules/
		3.解压好之后，切换到解压python目录
			因为我们下载的是源码。所以不能直接使用，必须要进行编译
			编译步骤： 使用root用户编译
			-1.su - : 切换到root用户
			-2.执行命令./configure:检查源码包
			-3.开始编译，执行命令：make 回车
		4.执行完第三步之后，python的版本仍然是2.7.5.因为当前系统环境变量中仍然是自带的python，所以只需要配置一下python3的环境变量即可
		命令：
			vi  /etc/profile
			最后添加：
				#PYTHON_HOME
				PYTHON_HOME=/opt/cdh5.14.2/modules/Python-3.6.5
				PATH=$PYTHON_HOME:$PATH
			保存，退出
			记得source /etc/profile
			完成之后，退出root用户，exit
			在普通用户下，也要source /etc/profile
		5.再次执行python -V，这个时候，应该显示python 3.6.5了

	-3.	注意：这一步，本来是应该做下面的步骤的
		将Spark的安装目录下的python目录下的lib中
			pyspark.zip
			py4j-0.10.4-src.zip
			这两个把放在上面找到的site-packages里面
		放好之后，解压这两个压缩包，解压完之后，把这两个包删除
		但是现在可以不需要做这两个步骤
		为什么不做呢？？？如果不做的话，那么python不就读不到pyspark的库了吗？
		原因是因为：
			在spark的python的目录下，已经解压好了pyspark，所以不需要再做上面的两步操作了。
		那为什么py4j-0.10.4-src.zip也不需要放置呢？
			因为linux的环境中，我们配置了JDK,SCALA,PYTHON三个环境，所以本身就可以转换。不需要再安装
			py4j-0.10.4-src.zip

============================================================================
二、Spark中使用python的pyspark脚本编写代码
1.切换到spark目录
cd /opt/cdh5.14.2/modules/spark-2.2.1-bin-2.6.0-cdh5.14.2
2.执行命令:bin/pyspark
报错：java.net.ConnectException: Call From superman-bigdata.com/172.31.210.61 to superman-bigdata.com:9000 failed on connection exception: java.net.ConnectException: 拒绝连接; For more details see: http://wiki.apache.org/hadoop/ConnectionRefused
表示连接HDFS的namenode服务拒绝了，也就是说hdfs的服务没有打开
开启HDFS的服务
sbin/hadoop-daemon.sh start namenode
sbin/hadoop-daemon.sh start datanode

报错：20/03/11 15:08:20 WARN metastore: Failed to connect to the MetaStore Server...
20/03/11 15:08:21 WARN Hive: Failed to access metastore. This class should not accessed in runtime.
org.apache.hadoop.hive.ql.metadata.HiveException: java.lang.RuntimeException: Unable to instantiate org.apache.hadoop.hive.ql.metadata.SessionHiveMetaStoreClient
表示hive的元数据服务没有开启
开启hive的元数据服务
bin/hive --service metastore &

3.在pyspark命令行中编写一个简单的wordcount
list = [“hadoop”,“hbase”,“spark”,“hadoop”,“hadoop”,“hbase”,“spark”]
rdd = sc.parallelize(list)
rdd1 = rdd.map(lambda word : (word,1))
rdd2 = rdd1.reduceByKey(lambda a,b : a + b)
rdd2.collect()
# [(‘hadoop’, 3), (‘spark’, 2), (‘hbase’, 2)]

4.课堂案例：读取HDFS上的一个数据文件，计算词频统计
path = “/input/wc.txt”
rdd = sc.textFile(path)
rdd1 = rdd.flatMap(lambda line : line.split("\t"))
rdd2 = rdd1.map(lambda word : (word,1))
rdd3 = rdd2.reduceByKey(lambda a,b : a + b)
rdd3.collect()

============================================================================
三、在windows下的IDEA中编写pyspark程序
from pyspark import SparkConf,SparkContext
import os
“”"
Could not find valid SPARK_HOME while searching
[‘C:\Users\ibf\Desktop\杨浦大数据43班\SparkSQL\代码\SparkDemo\src\main\python\PySpark’,
‘D:\IDEA\Anaconda3-5.2.0\lib\site-packages\pyspark’,
‘D:\IDEA\Anaconda3-5.2.0\lib\site-packages\pyspark’,
‘D:\IDEA\Anaconda3-5.2.0\lib’]
报错：找不到spark的环境变量，SPARK_HOME,也就是说必须要在windows上配置spark的环境变量
解决方法：必须在windows上解压一个spark。
方式一：在windows上配置spark的系统环境变量，永久生效的
方式二：在当前程序中配置临时环境变量（只是当前程序生效的）
方式三：直接在代码中给定环境变量（只是当前程序生效的）

报错：Exception: Python in worker has different version 2.7 than that in driver 3.6,
PySpark cannot run with different minor versions.Please check environment variables
PYSPARK_PYTHON and PYSPARK_DRIVER_PYTHON are correctly set.
解决方法：
直接在代码中给定环境变量（只是当前程序生效的）
“”"

#添加spark的环境变量
if ‘SPARK_HOME’ not in os.environ:
os.environ[‘SPARK_HOME’] = “D:\spark-2.2.1-bin-2.6.0-cdh5.14.2”
os.environ[‘PYSPARK_PYTHON’] = “D:\IDEA\Anaconda3-5.2.0\python.exe”

#1.构建上下文
“”"
scala代码:
val config = new SparkConf()
.setMaster(“local[]")
.setAppName(“Demo01”)
val sc = SparkContext.getOrCreate(config)
“”"
config = SparkConf()
.setMaster("local[]”)
.setAppName(“Demo01”)
sc = SparkContext.getOrCreate(config)

#2.读取数据形成RDD
list = [1,2,3,4,5,6]
rdd = sc.parallelize(list,3)
print(rdd.collect())

#查看当前RDD的分区数

count = rdd.getNumPartitions()

print(count)

#查看每个分区中具体的数据

#result = rdd.glom().collect()
#print(result)

###RDD下面常用的算子
##转换类算子map、flatMap
#map

rdd1 = rdd.map(lambda x : (x,x+1,x+2))

print(rdd1.collect())

#flatMap

rdd2 = rdd.flatMap(lambda x : (x,x+1,x+2))

print(rdd2.collect())

#总结：flatMap是在map的基础上对结果进行扁平化操作

##聚合类算子reduce fold aggregate
#reduce def reduce(self, f)

result1 = rdd.reduce(lambda a,b: a + b)

print(result1)

#fold def fold(self, zeroValue, op)

result2 = rdd.fold(0,lambda a,b : a + b)

print(result2)

result3 = rdd.fold("",lambda a ,b : a + str(b))

print(result3)

#aggregate def aggregate(self, zeroValue, seqOp, combOp)
#zeroValue:初始值，给的是临时聚合值的初始值
#seqOp：第一阶段聚合，也称之为局部聚合，分区内聚合
#combOp:第二阶段聚合，也称之为全局聚合，各分区临时结果聚合

zeroValue = 0

seqOp = lambda a ,b : a + b

combOp = lambda c ,d :c + d

result4 = rdd.aggregate(zeroValue, seqOp, combOp)

print(result4)

###过滤和去重 filter、distinct

rdd1 = rdd.flatMap(lambda x : (x,x+1,x+2))

print(rdd1.collect())

#[1, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 6, 5, 6, 7, 6, 7, 8]

#filter def filter(self, f)

rdd2 = rdd1.filter(lambda x : x % 2 == 0 )

print(rdd2.collect())

#distinct

rdd3 = rdd1.distinct()

print(rdd3.collect())

###两个RDD之间的交集，并集，差集，笛卡尔积

rdd0 = sc.parallelize([‘C’,‘A’,‘B’,‘B’])

rdd1 = sc.parallelize([‘A’,‘A’,‘B’,‘D’])

#交集 intersection

rdd2 = rdd0.intersection(rdd1)

print(rdd2.collect())

#并集 union

rdd3 = rdd0.union(rdd1)

print(rdd3.collect())

#差集 subtract

rdd4 = rdd0.subtract(rdd1)

print(rdd4.collect())

#笛卡尔积 cartesian

rdd5 = rdd0.cartesian(rdd1)

print(rdd5.collect())

###排序和分组 sortBy groupBy
#sort def sortBy(self, keyfunc, ascending=True, numPartitions=None):
rdd2 = rdd.sortBy(keyfunc=lambda x : x,ascending = False)
print(rdd2.collect())

#groupBy def groupBy(self, f, numPartitions=None, partitionFunc=portable_hash):
rdd3 = rdd.groupBy(f=lambda x : x % 2 ==0)
print(rdd3.collect())