pyspark精简笔记

spark = sparkSession.builder
.master("")
.appName("")
.getOrCreate()

sc = spark.sparkContext

rdd1 = sc.parallelize(array / list / list(range(10)))



"""
pyspark sql
"""

file_path = "path.parquet"
parquet_df = spark.read.load(file_path, format="parquet")
parquet_df = spark.read.parquet(file_path)
parquet_df.show()

orc_path = "path.orc"
orc_df = spark.read.format("orc").load(orc_path)
orc_df = spark.read.load(orc_path, format="orc")
orc_df = spark.read.orc(orc_path)
orc_df.show()

jdbc_df = spark.read.format("jdbc")
.option(url="", dbtable="", user="", password="")
.load()
jdbc_df=spark.read
.jdbc("url","dbtable",properties={"user":"root","password":"admin"})
jdbc_df=spark.read.format("jdbc")
.option("url","")
.option("dbtable","")
.option("user","root")
.option("password","admin")
.option("customSchema","id DECIMAL(38,0),name STRING,age LONG")
.load()
jdbc_df.show()


#读取图像文件创建df
image_path=""
image_df=spark.read.format("image").option("dropInvalid","true").load(image_path)
image_df.select("image.origin","image.width","image.height","image.nChannels","image.mode").show(truncate=False)


avro_path="path.avro"
avro_df=spark.read.format("avro").load(avro_path)
avro_df.show()



#转换行动算子
"""
选择数据：select
删除某列：drop
过滤数据：where 和 filter(同义的)
限制返回的数量：limit
重命名列：withColumnRenamed
增加一个新的列：withColumn
数据分组：groupBy
数据排序：orderBy 和 sort（等价的）
"""
df.columns  #列名
df.select("colName","colName").show()
df.where(col("colName") > 1).show()  #where=filter
df.where("year<2000")
df.filter("year != 2000")
df.filter(col("year").isin([2001,2022]))
df.where("year>=2000" and length("title") <5)
df.select(expr("colName > 1"),(col("colName") > 1).alias("addCol")).show()  #expr和col一样
df.select( ((col("year")-col("year"))%10).alias("decade") )
df.selectExpr("*","(year-year%10)as decade","count(distinct(actor)) as actors")
df.select("title").distinct()
df.dropDuplicates("title")
df.sort(col("title_length").desc())
df.sort(desc("title_length"))
df.orderBy(col("title_length").desc(),"year") #orderBy=sort
df.groupBy("year").count().orderBy(col("count").desc).show(5)
df.groupBy("year").count().where("count>2000").limit(10).show(5)
df.union(df)   #union all
df.withColumn("addColName","colValue")   #如果列名存在则是替换
df.withColumnRenamed("oldName","newName")
df.dorp("colName","colName")

df.sample(false,0.003).show()  #执行带有无放回和比例因子的抽样
df.sample(true,0..003,123456).show() #执行带有有放回和比例因子、种子的抽样
#randomSplit(weights)：随机分割数据集，其中参数 weights 是一个数组 Array，其元素代表各部分所占的比例
sub_df=df.randomSplit([0.6,0.3,0.1])
sub_df[0].count()+sub_df[1].count()+sub_df[2].count()==df.count()


#action
#show count first head(3) take collect columns

#计算数字列和字符串列的统计信息：count,mean,stddev,min,max
df.describe("colName","colName")
df.select("colName").summary()  #多了25，50，75%


#json orc parquet
df.write
.format( json、parquet、jdbc、orc、libsvm、csv、)
.mode(append,overwrite,ignore,error).option(...)
    .partitionBy(...).bucketBy(...).sortBy(...)
    .save(path)
df.write.csv()
df.write.json()
df.write.orc()
df.write.parquet()
df.write.jdbc()

props={
    "driver":"org.mariadb.jdbc.Driver",
    "user":"root",
    "password":"admin"
}
url="jdbc:mysql:..."
df.write.mode("append").jdbc(url=url,table="spark.students",properties=props)


df.repartition("year").write.mode("overwrite").partitionBy("year").save(outpath)





#直接读取hdfs的文件
df=spark.sql("select * from parquet.'/data/spark/user.parquet'")
spark.sql("create temporary view t "
          "using org.apache.spark.sql.parquet "
          "options(path 'file:///home/...')")
spark.sql("select * from t").show()

spark.sql("create temporary view t "
          "using org.apache.spark.sql.jdbc "
          "options( url 'jdbc:mysql://...',dbtable 'people',user 'root',password 'admin')")
spark.sql("select * from t").show()



#数据库中注册的表有哪些
print(spark.catalog.listTables())
#返回给定表、视图的所有列
print(spark.catalog.listColumns("t"))
#返回数据库中注册的函数列表
print(spark.catalog.listFunctions())
#cacheTable、uncacheTable、isCached 和 clearCache，包括缓存表、删除临时视图和清除缓存等。
df.createOrReplaceTempView("t")
spark.catalog.cacheTable("t")  #cache和persist是lazy执行的，cacheTable()是eager执行的


#======================================================================================================================
#pyspark sql 可视化
df_pandas=df.toPandas()

df_agg=df.groupBy("category").agg(collect_list("*")).alias("items")
for row in df_agg.collect():
    items=[ item.asDict() for item in row["Items"] ]
    print(pandas.DataFrame(items))  #category items


# 创建一个包含 3 个数字列和一个类别(颜色)的 spark dataframe
A = [random.normalvariate(0,1) for i in range(100)]
B = [random.normalvariate(1,2) for i in range(100)]
C = [random.normalvariate(-1,0.5) for i in range(100)]
col = [random.choice(['#e41a1c', '#377eb8', '#4eae4b']) for i in range(100)]

df = spark.createDataFrame(zip(A,B,C,col), ["A","B","C","col"])
pdf = df.toPandas()
stuff = scatter_matrix(pdf, alpha=0.7, figsize=(6, 6), diagonal='kde', color=pdf.col)
#======================================================================================================================

from pyspark.sql.functions import *
#pyspark sql 函数
#数学计算：abs，hypot，log，cbrt,round。。。
#字符串操作：（转换，提取）length，trim,ltrim,rtrim，concat
    lpad("col", 8, "-").alias("lpad"),   # 宽度为8，不够的话，左侧填充"-"
    rpad("col", 8, "=").alias("rpad")    # 宽度为8，不够的话，右侧填充"="
    lower("sentence").alias("lower"),          # 转小写
    upper("sentence").alias("upper"),          # 转大写
    initcap("sentence").alias("initcap"),  # 转首字母大写
    reverse("sentence").alias("reverse")       # 反转
    regexp_extract(),regexp_replace()    #通过传入的正则表达式来实现替换或提取。
#日期操作：
    将字符串转换为日期或时间戳：
    to_date('date').alias("date1"),
    to_timestamp('timestamp').alias("ts1"),
    to_date('date_str',"MM-dd-yyyy").alias("date2"),
    to_timestamp('ts_str',"MM-dd-yyyy mm:ss").alias("ts2"),
    unix_timestamp('timestamp').alias("unix_ts")

    将日期或时间戳转换为字符串：
    date_format('date1', "dd-MM-yyyy").alias("date_str"),
    date_format('ts1', "dd-MM-yyyy HH:mm:ss").alias("ts_str"),
    from_unixtime('unix_ts',"dd-MM-yyyy HH:mm:ss").alias("unix_ts_str")

    日期计算函数：
    datediff('leave_date', 'join_date').alias("days"),
    months_between('leave_date', 'join_date').alias("months"),
    last_day('leave_date').alias("last_day_of_mon")
    date_add('new_year', 14).alias("mid_month"),
    date_sub('new_year', 1).alias("new_year_eve"),
    next_day('new_year', "Mon").alias("next_mon")

    转换不规范的日期：
    data = [("Nov 05, 2018 02:46:47 AM",),("Nov 5, 2018 02:46:47 PM",)]
    df = spark.createDataFrame(data,schema=["times"])

    df.withColumn(
        "times2",
        from_unixtime(
            unix_timestamp("times", "MMM d, yyyy hh:mm:ss a"),
            "yyyy-MM-dd HH:mm:ss.SSSSSS"
        )
    ).show(truncate=False)

    处理时间序列数据：
    year('date').alias("year"),                # 年
    quarter('date').alias("quarter"),          # 季
    month('date').alias("month"),              # 月
    weekofyear('date').alias("woy"),           # 周
    dayofmonth('date').alias("dom"),           # 日
    dayofyear('date').alias("doy"),            # 天
    hour('date').alias("hour"),                # 小时
    minute('date').alias("minute"),            # 分
    second('date').alias("second")             # 秒

#处理集合元素的函数
    size("tasks").alias("size"),                             # 数组大小
    sort_array("tasks").alias("sorted_tasks"),             # 对数组排序
    array_contains("tasks", "去烫头").alias("是否去烫头")  # 是否包含
    explode()           #表函数将为数组中的每一个元素创建一个新行

#JSON处理函数:from_json()、get_json_object() ,to_json()

#monotonically_increasing_id:单调递增的id
#when根据条件列表来评估一个值并返回一个值
#coalesce(colName,lit("1"))

#f：函数(x: Column) -> Column: ... 返回布尔表达式。
# 可以使用Column的方法，pyspark.sql.functions和Scala中定义的函数UserDefinedFunctions。
# 不支持 Python UserDefinedFunctions
#df.select(forall("values", lambda x: x.rlike("foo")).alias("all_foo")).show()
exists(col,f)  #返回true，false，null
forall(col,f)   #遍历数组中的元素
filter(col,f)  #过滤数组中的元素
trandform(col,f) #map
aggregate(col,initialValue,merge,finish=None)  #相当于Scala中的fold
zip_with(left,right,f)  #拉链，短的补充空值


count(col),countDistinct(col)
approx_count_distinct(col)  #每组中成员唯一近似数量
min,max,sum,sumDistinct,avg
collect_list,collect_set
skewness(col)  #每组中给定列的值的偏斜度
kurtosis(col)  #每组中给定列的值的峰值
variance(col)  #..............无偏方差
stddev(col)  #标准差
df.groupBy().agg()
df.groupBy(col).pivot(col).agg(min(),max(),avg())
df.groupBy(col).pivot(col,["col_value1"]).agg(min(),max(),avg())
df.rollup("col1","col2").agg(count("col3"))  #从左（0）向右加精度count
df.cube("col1","col2").agg(count("col3"))    #比rollup多了col2粒度的count



rank,dense_rank,ntile(n),row_number
cume_dist #返回一个frame的值的累积分布。换句话说，低于当前行的行的比例
lag,lead



#两个df join后有相同名字的列：1.表明df.col 2.重命名


#读写hive
spark.read.table("tableName").show()
spark.table("tableName").show()
spark.range(0,10).write.saveAsTable("tableName")
spark.range(0,10).write.bucketBy("分桶数","分桶字段").saveAsTable("tableName")
#（1）目前 bucketBy 需要和 saveAsTable()结合使用，而不能和 save()一起来用。
#（2）目前只支持 sortBy(...)和 bucketBy(...)结合使用，并且排序列不应该是分区列的一部分
create table tName(id int) using hive options(fileFormat 'parquet')