datafram 操作集锦
Spark Python API 官方文档中文版》 之 pyspark.sql (二)
2017-11-04 22:13 by 牛仔裤的夏天, 365 阅读, 0 评论, 收藏, 编辑
官网地址:http://spark.apache.org/docs/1.6.2/api/python/pyspark.sql.html
pyspark.sql module
Module Context
Spark SQL和DataFrames重要的类有:
pyspark.sql.SQLContext DataFrame和SQL方法的主入口
pyspark.sql.DataFrame 将分布式数据集分组到指定列名的数据框中
pyspark.sql.Column DataFrame中的列
pyspark.sql.Row DataFrame数据的行
pyspark.sql.HiveContext 访问Hive数据的主入口
pyspark.sql.GroupedData 由DataFrame.groupBy()创建的聚合方法集
pyspark.sql.DataFrameNaFunctions 处理丢失数据(空数据)的方法
pyspark.sql.DataFrameStatFunctions 统计功能的方法
pyspark.sql.functions DataFrame可用的内置函数
pyspark.sql.types 可用的数据类型列表
pyspark.sql.Window 用于处理窗口函数
3.class pyspark.sql.DataFrame(jdf, sql_ctx)
分布式的收集数据分组到命名列中。
一个DataFrame相当于在Spark SQL中一个相关的表,可在SQLContext使用各种方法创建,如:
- people = sqlContext.read.parquet("...")
一旦创建, 可以使用在DataFrame、Column中定义的不同的DSL方法操作。
从data frame中返回一列使用对应的方法:
- ageCol = people.age
一个更具体的例子:
- # To create DataFrame using SQLContext
- people = sqlContext.read.parquet("...")
- department = sqlContext.read.parquet("...")
- people.filter(people.age > 30).join(department, people.deptId == department.id)).groupBy(department.name, "gender").agg({"salary": "avg", "age": "max"})
3.1 agg(*exprs)
没有组的情况下聚集整个DataFrame (df.groupBy.agg()的简写)。

- >>> l=[('jack',5),('john',4),('tom',2)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> df.agg({"age": "max"}).collect()
- [Row(max(age)=5)]
- >>> from pyspark.sql import functions as F
- >>> df.agg(F.min(df.age)).collect()
- [Row(min(age)=2)]

3.2 alias(alias)
返回一个设置别名的新的DataFrame。

- >>> l=[('Alice',2),('Bob',5)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> from pyspark.sql.functions import *
- >>> df_as1 = df.alias("df_as1")
- >>> df_as2 = df.alias("df_as2")
- >>> joined_df = df_as1.join(df_as2, col("df_as1.name") == col("df_as2.name"), 'inner')
- >>> joined_df.select(col("df_as1.name"), col("df_as2.name"), col("df_as2.age")).collect()
- [Row(name=u'Alice', name=u'Alice', age=2), Row(name=u'Bob', name=u'Bob', age=5)]

3.3 cache()
用默认的存储级别缓存数据(MEMORY_ONLY_SER).
3.4 coalesce(numPartitions)
返回一个有确切的分区数的分区的新的DataFrame。
与在一个RDD上定义的合并类似, 这个操作产生一个窄依赖。 如果从1000个分区到100个分区,不会有shuffle过程, 而是每100个新分区会需要当前分区的10个。
- >>> df.coalesce(1).rdd.getNumPartitions()
- 1
3.5 collect()
返回所有的记录数为行的列表。
- >>> df.collect()
- [Row(age=2, name=u'Alice'), Row(age=5, name=u'Bob')]
3.6 columns
返回所有列名的列表。
- >>> df.columns
- ['age', 'name']
3.7 corr(col1, col2, method=None)
计算一个DataFrame相关的两列为double值。通常只支持皮尔森相关系数。DataFrame.corr()和DataFrameStatFunctions.corr()类似。
参数:● col1 – 第一列的名称
● col2 – 第二列的名称
● method – 相关方法.当前只支持皮尔森相关系数
3.8 count()
返回DataFrame的行数。
- >>> df.count()
- 2
3.9 cov(col1, col2)
计算由列名指定列的样本协方差为double值。DataFrame.cov()和DataFrameStatFunctions.cov()类似。
参数:● col1 – 第一列的名称
● col2 – 第二列的名称
3.10 crosstab(col1, col2)
计算给定列的分组频数表,也称为相关表。每一列的去重值的个数应该小于1e4.最多返回1e6个非零对.每一行的第一列会是col1的去重值,列名称是col2的去重值。第一列的名称是$col1_$col2. 没有出现的配对将以零作为计数。DataFrame.crosstab() and DataFrameStatFunctions.crosstab()类似。
参数:● col1 – 第一列的名称. 去重项作为每行的第一项。
● col2 – 第二列的名称. 去重项作为DataFrame的列名称。
3.11 cube(*cols)
创建使用指定列的当前DataFrame的多维立方体,这样可以聚合这些数据。

- >>> l=[('Alice',2),('Bob',5)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> df.cube('name', df.age).count().show()
- +-----+----+-----+
- | name| age|count|
- +-----+----+-----+
- | null| 2| 1|
- |Alice|null| 1|
- | Bob| 5| 1|
- | Bob|null| 1|
- | null| 5| 1|
- | null|null| 2|
- |Alice| 2| 1|
- +-----+----+-----+

3.12 describe(*cols)
计算数值列的统计信息。
包括计数,平均,标准差,最小和最大。如果没有指定任何列,这个函数计算统计所有数值列。

- >>> df.describe().show()
- +-------+------------------+
- |summary| age|
- +-------+------------------+
- | count| 2|
- | mean| 3.5|
- | stddev|2.1213203435596424|
- | min| 2|
- | max| 5|
- +-------+------------------+
- >>> df.describe(['age', 'name']).show()
- +-------+------------------+-----+
- |summary| age| name|
- +-------+------------------+-----+
- | count| 2| 2|
- | mean| 3.5| null|
- | stddev|2.1213203435596424| null|
- | min| 2|Alice|
- | max| 5| Bob|
- +-------+------------------+-----+

3.13 distinct()
返回行去重的新的DataFrame。
- >>> l=[('Alice',2),('Alice',2),('Bob',5)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> df.distinct().count()
- 2
3.14 drop(col)
返回删除指定列的新的DataFrame。
参数:● col – 要删除列的字符串类型名称,或者要删除的列。
- >>> df.drop('age').collect()
- [Row(name=u'Alice'), Row(name=u'Bob')]
- >>> df.drop(df.age).collect()
- [Row(name=u'Alice'), Row(name=u'Bob')]

- >>> l1=[('Bob',5)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> l2=[('Bob',85)]
- >>> df2 = sqlContext.createDataFrame(l2,['name','height'])
- >>> df.join(df2, df.name == df2.name, 'inner').drop(df.name).collect()
- [Row(age=5, height=85, name=u'Bob')]
- >>> df.join(df2, df.name == df2.name, 'inner').drop(df2.name).collect()
- [Row(age=5, name=u'Bob', height=85)]

3.15 dropDuplicates(subset=None)
返回去掉重复行的一个新的DataFrame,通常只考虑某几列。
drop_duplicates()和dropDuplicates()类似。

- >>> from pyspark.sql import Row
- >>> df = sc.parallelize([Row(name='Alice', age=5, height=80),Row(name='Alice', age=5, height=80),Row(name='Alice', age=10, height=80)]).toDF()
- >>> df.dropDuplicates().show()
- +---+------+-----+
- |age|height| name|
- +---+------+-----+
- | 5| 80|Alice|
- | 10| 80|Alice|
- +---+------+-----+

- >>> df.dropDuplicates(['name', 'height']).show()
- +---+------+-----+
- |age|height| name|
- +---+------+-----+
- | 5| 80|Alice|
- +---+------+-----+
3.16 drop_duplicates(subset=None)
与以上相同。
3.17 dropna(how='any', thresh=None, subset=None)
返回一个删除null值行的新的DataFrame。dropna()和dataframenafunctions.drop()类似。
参数:● how – 'any'或者'all'。如果'any',删除包含任何空值的行。如果'all',删除所有值为null的行。
● thresh – int,默认为None,如果指定这个值,删除小于阈值的非空值的行。这个会重写'how'参数。
● subset – 选择的列名称列表。

- >>> l=[('Alice',2),('Bob',5)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> dfnew = df.cube('name', df.age).count()
- >>> dfnew.show()
- +-----+----+-----+
- | name| age|count|
- +-----+----+-----+
- | null| 2| 1|
- |Alice|null| 1|
- | Bob| 5| 1|
- | Bob|null| 1|
- | null| 5| 1|
- | null|null| 2|
- |Alice| 2| 1|
- +-----+----+-----+
- >>> dfnew.na.drop().show()
- +-----+---+-----+
- | name|age|count|
- +-----+---+-----+
- | Bob| 5| 1|
- |Alice| 2| 1|
- +-----+---+-----+

3.18 dtypes
返回所有列名及类型的列表。
- >>> df.dtypes
- [('age', 'int'), ('name', 'string')]
3.19 explain(extended=False)
将(逻辑和物理)计划打印到控制台以进行调试。
参数:● extended – boolean类型,默认为False。如果为False,只打印物理计划。
- >>> df.explain()
- == Physical Plan ==
- Scan ExistingRDD[age#0,name#1]

- >>> df.explain(True)
- == Parsed Logical Plan ==
- ...
- == Analyzed Logical Plan ==
- ...
- == Optimized Logical Plan ==
- ...
- == Physical Plan ==
- ...

3.20 fillna(value, subset=None)
替换空值,和na.fill()类似,DataFrame.fillna()和dataframenafunctions.fill()类似。
参数:● value - 要代替空值的值有int,long,float,string或dict.如果值是字典,subset参数将被忽略。值必须是要替换的列的映射,替换值必须是int,long,float或者string.
● subset - 要替换的列名列表。在subset指定的列,没有对应数据类型的会被忽略。例如,如果值是字符串,subset包含一个非字符串的列,这个非字符串的值会被忽略。

- >>> l=[('Alice',2),('Bob',5)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> dfnew = df.cube('name', df.age).count()
- >>> dfnew.show()
- +-----+----+-----+
- | name| age|count|
- +-----+----+-----+
- | null| 2| 1|
- |Alice|null| 1|
- | Bob| 5| 1|
- | Bob|null| 1|
- | null| 5| 1|
- | null|null| 2|
- |Alice| 2| 1|
- +-----+----+-----+
- >>> dfnew.na.fill(50).show()
- +-----+---+-----+
- | name|age|count|
- +-----+---+-----+
- | null| 2| 1|
- |Alice| 50| 1|
- | Bob| 5| 1|
- | Bob| 50| 1|
- | null| 5| 1|
- | null| 50| 2|
- |Alice| 2| 1|
- +-----+---+-----+
- >>> dfnew.na.fill({'age': 50, 'name': 'unknown'}).show()
- +-------+---+-----+
- | name|age|count|
- +-------+---+-----+
- |unknown| 2| 1|
- | Alice| 50| 1|
- | Bob| 5| 1|
- | Bob| 50| 1|
- |unknown| 5| 1|
- |unknown| 50| 2|
- | Alice| 2| 1|
- +-------+---+-----+

3.21 filter(condition)
用给定的条件过滤行。
where()和filter()类似。
参数:● 条件 - 一个列的bool类型或字符串的SQL表达式。

- >>> l=[('Alice',2),('Bob',5)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> df.filter(df.age > 3).collect()
- [Row(age=5, name=u'Bob')]
- >>> df.where(df.age == 2).collect()
- [Row(age=2, name=u'Alice')]
- >>> df.filter("age > 3").collect()
- [Row(age=5, name=u'Bob')]
- >>> df.where("age = 2").collect()
- [Row(age=2, name=u'Alice')]

3.22 first()
返回第一行。
- >>> df.first()
- Row(age=2, name=u'Alice')
3.23 flatMap(f)
返回在每行应用F函数后的新的RDD,然后将结果压扁。
是df.rdd.flatMap()的简写。
- >>> df.flatMap(lambda p: p.name).collect()
- [u'A', u'l', u'i', u'c', u'e', u'B', u'o', u'b']
3.24 foreach(f)
应用f函数到DataFrame的所有行。
是df.rdd.foreach()的简写。
- >>> def f(person):
- ... print(person.name)
- >>> df.foreach(f)
- Alice
- Bob
3.25 foreachPartition(f)
应用f函数到DataFrame的每一个分区。
是 df.rdd.foreachPartition()的缩写。

- >>> def f(people):
- ... for person in people:
- ... print(person.name)
- >>> df.foreachPartition(f)
- Alice
- Bob

3.26 freqItems(cols, support=None)
参数:● cols – 要计算重复项的列名,为字符串类型的列表或者元祖。
● support – 要计算频率项的频率值。默认是1%。参数必须大于1e-4.
3.27 groupBy(*cols)
使用指定的列分组DataFrame,这样可以聚合计算。可以从GroupedData查看所有可用的聚合方法。
groupby()和groupBy()类似。
参数:● cols – 分组依据的列。每一项应该是一个字符串的列名或者列的表达式。

- >>> df.groupBy().avg().collect()
- [Row(avg(age)=3.5)]
- >>> df.groupBy('name').agg({'age': 'mean'}).collect()
- [Row(name=u'Alice', avg(age)=2.0), Row(name=u'Bob', avg(age)=5.0)]
- >>> df.groupBy(df.name).avg().collect()
- [Row(name=u'Alice', avg(age)=2.0), Row(name=u'Bob', avg(age)=5.0)]
- >>> df.groupBy(['name', df.age]).count().collect()
- [Row(name=u'Bob', age=5, count=1), Row(name=u'Alice', age=2, count=1)]

3.28 groupby(*cols)
和以上一致
3.29 head(n=None)
返回前n行
参数:● n – int类型,默认为1,要返回的行数。
返回值: 如果n大于1,返回行列表,如果n为1,返回单独的一行。
- >>> df.head()
- Row(age=2, name=u'Alice')
- >>> df.head(1)
- [Row(age=2, name=u'Alice')]
3.30 insertInto(tableName, overwrite=False)
插入DataFrame内容到指定表。
注:在1.4中已过时,使用DataFrameWriter.insertInto()代替。
3.31 intersect(other)
返回新的DataFrame,包含仅同时在当前框和另一个框的行。
相当于SQL中的交集。
3.32 intersect(other)
如果collect()和take()方法可以运行在本地(不需要Spark executors)那么返回True
3.33 join(other, on=None, how=None)
使用给定的关联表达式,关联另一个DataFrame。
以下执行df1和df2之间完整的外连接。
参数:● other – 连接的右侧
● on – 一个连接的列名称字符串, 列名称列表,一个连接表达式(列)或者列的列表。如果on参数是一个字符串或者字符串列表,表示连接列的名称,这些名称必须同时存在join的两个表中, 这样执行的是一个等价连接。
● how – 字符串,默认'inner'。inner,outer,left_outer,right_outer,leftsemi之一。
- >>> l=[('Alice',2),('Bob',5)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> l2=[('Tom',80),('Bob',85)]
- >>> df2 = sqlContext.createDataFrame(l2,['name','height'])
- >>> df.join(df2, df.name == df2.name, 'outer').select(df.name, df2.height).collect()
- [Row(name=None, height=80), Row(name=u'Alice', height=None), Row(name=u'Bob', height=85)]
- >>> df.join(df2, 'name', 'outer').select('name', 'height').collect()
- [Row(name=u'Tom', height=80), Row(name=u'Alice', height=None), Row(name=u'Bob', height=85)]
- >>> l3=[('Alice',2,60),('Bob',5,80)]
- >>> df3 = sqlContext.createDataFrame(l3,['name','age','height'])
- >>> cond = [df.name == df3.name, df.age == df3.age]
- >>> df.join(df3, cond, 'outer').select(df.name, df3.age).collect()
- [Row(name=u'Bob', age=5), Row(name=u'Alice', age=2)]
- >>> df.join(df2, 'name').select(df.name, df2.height).collect()
- [Row(name=u'Bob', height=85)]
- >>> l4=[('Alice',1),('Bob',5)]
- >>> df4 = sqlContext.createDataFrame(l4,['name','age'])
- >>> df.join(df4, ['name', 'age']).select(df.name, df.age).collect()
- [Row(name=u'Bob', age=5)]
3.34 limit(num)
将结果计数限制为指定的数字。
- >>> df.limit(1).collect()
- [Row(age=2, name=u'Alice')]
- >>> df.limit(0).collect()
- []
3.35 map(f)
通过每行应用f函数返回新的RDD。
是 df.rdd.map()的缩写。
- >>> df.map(lambda p: p.name).collect()
- [u'Alice', u'Bob']
3.36 mapPartitions(f, preservesPartitioning=False)
通过每个分区应用f函数返回新的RDD
是df.rdd.mapPartitions()的缩写。
- >>> rdd = sc.parallelize([1, 2, 3, 4], 4)
- >>> def f(iterator): yield 1
- ...
- >>> rdd.mapPartitions(f).sum()
- 4
3.37 na
返回DataFrameNaFunctions用于处理缺失值。
3.38 orderBy(*cols, **kwargs)
返回按照指定列排序的新的DataFrame。
参数:● cols – 用来排序的列或列名称的列表。
● ascending – 布尔值或布尔值列表(默认 True). 升序排序与降序排序。指定多个排序顺序的列表。如果指定列表, 列表的长度必须等于列的长度。

- >>> l=[('Alice',2),('Bob',5)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> df.sort(df.age.desc()).collect()
- [Row(name=u'Bob', age=5), Row(name=u'Alice', age=2)]
- >>> df.sort("age", ascending=False).collect()
- [Row(name=u'Bob', age=5), Row(name=u'Alice', age=2)]
- >>> df.orderBy(df.age.desc()).collect()
- [Row(name=u'Bob', age=5), Row(name=u'Alice', age=2)]
- >>> from pyspark.sql.functions import *
- >>> df.sort(asc("age")).collect()
- [Row(name=u'Alice', age=2), Row(name=u'Bob', age=5)]
- >>> df.orderBy(desc("age"), "name").collect()
- [Row(name=u'Bob', age=5), Row(name=u'Alice', age=2)]
- >>> df.orderBy(["age", "name"], ascending=[0, 1]).collect()
- [Row(name=u'Bob', age=5), Row(name=u'Alice', age=2)]

3.39 persist(storageLevel=StorageLevel(False, True, False, False, 1))
设置存储级别以在第一次操作运行完成后保存其值。这只能用来分配新的存储级别,如果RDD没有设置存储级别的话。如果没有指定存储级别,默认为(memory_only_ser)。
3.40 printSchema()
打印schema以树的格式
- >>> df.printSchema()
- root
- |-- name: string (nullable = true)
- |-- age: long (nullable = true)
3.41 randomSplit(weights, seed=None)
按照提供的权重随机的划分DataFrame。
参数:● weights – doubles类型的列表做为权重来划分DataFrame。权重会被恢复如果总值不到1.0。
● seed – random的随机数。

- >>> l4=[('Alice',1),('Bob',5),('Jack',8),('Tom',10)]
- >>> df4 = sqlContext.createDataFrame(l4,['name','age'])
- >>> splits = df4.randomSplit([1.0, 2.0],24)
- >>> splits[0].count()
- 1
- >>> splits[1].count()
- 3

3.42 rdd
返回内容为行的RDD。
3.43 registerAsTable(name)
注:在1.4中已过时,使用registerTempTable()代替。
3.44 registerTempTable(name)
使用给定的名字注册该RDD为临时表
这个临时表的有效期与用来创建这个DataFrame的SQLContext相关
- >>> df.registerTempTable("people")
- >>> df2 = sqlContext.sql("select * from people")
- >>> sorted(df.collect()) == sorted(df2.collect())
- True
3.45 repartition(numPartitions, *cols)
按照给定的分区表达式分区,返回新的DataFrame。产生的DataFrame是哈希分区。
numPartitions参数可以是一个整数来指定分区数,或者是一个列。如果是一个列,这个列会作为第一个分区列。如果没有指定,将使用默认的分区数。
1.6版本修改: 添加可选参数可以指定分区列。如果分区列指定的话,numPartitions也是可选的。

- >>> l=[('Alice',2),('Bob',5)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> df.repartition(10).rdd.getNumPartitions()
- 10
- >>> data = df.unionAll(df).repartition("age")
- >>> data.show()
- +-----+---+
- | name|age|
- +-----+---+
- |Alice| 2|
- |Alice| 2|
- | Bob| 5|
- | Bob| 5|
- +-----+---+
- >>> data = data.repartition(7, "age")
- >>> data.show()
- +-----+---+
- | name|age|
- +-----+---+
- | Bob| 5|
- | Bob| 5|
- |Alice| 2|
- |Alice| 2|
- +-----+---+
- >>> data.rdd.getNumPartitions()
- 7
- >>> data = data.repartition("name", "age")
- >>> data.show()
- +-----+---+
- | name|age|
- +-----+---+
- | Bob| 5|
- | Bob| 5|
- |Alice| 2|
- |Alice| 2|
- +-----+---+

3.46 replace(to_replace, value, subset=None)
返回用另外一个值替换了一个值的新的DataFrame。DataFrame.replace() 和 DataFrameNaFunctions.replace() 类似。
参数:● to_replace – 整形,长整形,浮点型,字符串,或者列表。要替换的值。如果值是字典,那么值会被忽略,to_replace必须是一个从列名(字符串)到要替换的值的映射。要替换的值必须是一个整形,长整形,浮点型,或者字符串。
● value – 整形,长整形,浮点型,字符串或者列表。要替换为的值。要替换为的值必须是一个整形,长整形,浮点型,或者字符串。如果值是列表或者元组,值应该和to_replace有相同的长度。
● subset – 要考虑替换的列名的可选列表。在subset指定的列如果没有匹配的数据类型那么将被忽略。例如,如果值是字符串,并且subset参数包含一个非字符串的列,那么非字符串的列被忽略。

- >>> l4=[('Alice',10,80),('Bob',5,None),('Tom',None,None),(None,None,None)]
- >>> df4 = sqlContext.createDataFrame(l4,['name','age','height'])
- >>> df4.na.replace(10, 20).show()
- +-----+----+------+
- | name| age|height|
- +-----+----+------+
- |Alice| 20| 80|
- | Bob| 5| null|
- | Tom|null| null|
- | null|null| null|
- +-----+----+------+
- >>> df4.na.replace(['Alice', 'Bob'], ['A', 'B'], 'name').show()
- +----+----+------+
- |name| age|height|
- +----+----+------+
- | A| 10| 80|
- | B| 5| null|
- | Tom|null| null|
- |null|null| null|
- +----+----+------+

3.47 rollup(*cols)
使用指定的列为当前的DataFrame创建一个多维汇总, 这样可以聚合这些数据。

- >>> l=[('Alice',2,80),('Bob',5,None)]
- >>> df = sqlContext.createDataFrame(l,['name','age','height'])
- >>> df.rollup('name', df.age).count().show()
- +-----+----+-----+
- | name| age|count|
- +-----+----+-----+
- |Alice|null| 1|
- | Bob| 5| 1|
- | Bob|null| 1|
- | null|null| 2|
- |Alice| 2| 1|
- +-----+----+-----+

3.48 sample(withReplacement, fraction, seed=None)
返回DataFrame的子集采样。
- >>> df.sample(False, 0.5, 42).count()
- 2
3.49 sampleBy(col, fractions, seed=None)
根据每个层次上给出的分数,返回没有替换的分层样本。
返回没有替换的分层抽样 基于每层给定的一小部分 在给定的每层的片段
参数:● col – 定义层的列
● fractions – 每层的抽样数。如果没有指定层, 将其数目视为0.
● seed – 随机数
返回值: 返回代表分层样本的新的DataFrame

- >>> from pyspark.sql.functions import col
- >>> dataset = sqlContext.range(0, 100).select((col("id") % 3).alias("key"))
- >>> sampled = dataset.sampleBy("key", fractions={0: 0.1, 1: 0.2}, seed=0)
- >>> sampled.groupBy("key").count().orderBy("key").show()
- +---+-----+
- |key|count|
- +---+-----+
- | 0| 5|
- | 1| 9|
- +---+-----+

3.50 save(path=None, source=None, mode='error', **options)
保存DataFrame的数据到数据源。
注:在1.4中已过时,使用DataFrameWriter.save()代替。
3.51 saveAsParquetFile(path)
保存内容为一个Parquet文件,代表这个schema。
注:在1.4中已过时,使用DataFrameWriter.parquet() 代替。
3.52 saveAsTable(tableName, source=None, mode='error', **options)
将此DataFrame的内容作为表保存到数据源。
注:在1.4中已过时,使用DataFrameWriter.saveAsTable() 代替。
3.53 schema
返回DataFrame的schema为types.StructType。
- >>> l=[('Alice',2),('Bob',5)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> df.schema
- StructType(List(StructField(name,StringType,true),StructField(age,LongType,true)))
3.54 select(*cols)
提供一组表达式并返回一个新的DataFrame。
参数:● cols – 列名(字符串)或表达式(列)列表。 如果其中一列的名称为“*”,那么该列将被扩展为包括当前DataFrame中的所有列。

- >>> l=[('Alice',2),('Bob',5)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> df.select('*').collect()
- [Row(name=u'Alice', age=2), Row(name=u'Bob', age=5)]
- >>> df.select('name', 'age').collect()
- [Row(name=u'Alice', age=2), Row(name=u'Bob', age=5)]
- >>> df.select(df.name, (df.age + 10).alias('age')).collect()
- [Row(name=u'Alice', age=12), Row(name=u'Bob', age=15)]

3.55 selectExpr(*expr)
投射一组SQL表达式并返回一个新的DataFrame。
这是接受SQL表达式的select()的变体。
- >>> df.selectExpr("age * 2", "abs(age)").collect()
- [Row((age * 2)=4, abs(age)=2), Row((age * 2)=10, abs(age)=5)]
3.56 show(n=20, truncate=True)
将前n行打印到控制台。
参数:● n – 要显示的行数。
● truncate – 是否截断长字符串并对齐单元格。

- >>> df
- DataFrame[name: string, age: bigint]
- >>> df.show()
- +-----+---+
- | name|age|
- +-----+---+
- |Alice| 2|
- | Bob| 5|
- +-----+---+

3.57 sort(*cols, **kwargs)
返回按指定列排序的新DataFrame。
参数:● cols – 要排序的列或列名称列表。
● ascending – 布尔值或布尔值列表(默认为True)。 排序升序降序。 指定多个排序顺序的列表。 如果指定了列表,列表的长度必须等于列的长度。

- >>> df.sort(df.age.desc()).collect()
- [Row(name=u'Bob', age=5), Row(name=u'Alice', age=2)]
- >>> df.sort("age", ascending=False).collect()
- [Row(name=u'Bob', age=5), Row(name=u'Alice', age=2)]
- >>> df.orderBy(df.age.desc()).collect()
- [Row(name=u'Bob', age=5), Row(name=u'Alice', age=2)]
- >>> from pyspark.sql.functions import *
- >>> df.sort(asc("age")).collect()
- [Row(name=u'Alice', age=2), Row(name=u'Bob', age=5)]
- >>> df.orderBy(desc("age"), "name").collect()
- [Row(name=u'Bob', age=5), Row(name=u'Alice', age=2)]
- >>> df.orderBy(["age", "name"], ascending=[0, 1]).collect()
- [Row(name=u'Bob', age=5), Row(name=u'Alice', age=2)]

3.58 sortWithinPartitions(*cols, **kwargs)
返回一个新的DataFrame,每个分区按照指定的列排序。
参数:● cols – 要排序的列或列名称列表。
● ascending – 布尔值或布尔值列表(默认为True)。 排序升序降序。 指定多个排序顺序的列表。 如果指定了列表,列表的长度必须等于列的长度。
- >>> df.sortWithinPartitions("age", ascending=False).show()
- +-----+---+
- | name|age|
- +-----+---+
- |Alice| 2|
- | Bob| 5|
- +-----+---+
3.59 stat
返回统计功能的DataFrameStatFunctions。
3.60 subtract(other)
返回一个新的DataFrame,这个DataFrame中包含的行不在另一个DataFrame中。
这相当于SQL中的EXCEPT。
3.61 take(num)
返回前num行的行列表
- >>> df.take(2)
- [Row(name=u'Alice', age=2), Row(name=u'Bob', age=5)]
3.62 toDF(*cols)
返回一个新类:具有新的指定列名称的DataFrame。
参数:● cols – 新列名列表(字符串)。
- >>> df.toDF('f1', 'f2').collect()
- [Row(f1=u'Alice', f2=2), Row(f1=u'Bob', f2=5)]
3.63 toJSON(use_unicode=True)
将DataFrame转换为字符串的RDD。
每行都将转换为JSON格式作为返回的RDD中的一个元素。
- >>> df.toJSON().first()
- u'{"name":"Alice","age":2}'
3.64 toPandas()
将此DataFrame的内容返回为Pandas pandas.DataFrame。
这只有在pandas安装和可用的情况下才可用。
- >>> df.toPandas()
- age name
- 0 2 Alice
- 1 5 Bob
3.65 unionAll(other)
返回包含在这个frame和另一个frame的行的联合的新DataFrame。
这相当于SQL中的UNION ALL。
3.66 unpersist(blocking=True)
将DataFrame标记为非持久性,并从内存和磁盘中删除所有的块。
3.67 where(condition)
使用给定表达式过滤行。
where()是filter()的别名。
参数:● condition – 一个布尔类型的列或一个SQL表达式的字符串。

- >>> l=[('Alice',2),('Bob',5)]
- >>> df = sqlContext.createDataFrame(l,['name','age'])
- >>> df.filter(df.age > 3).collect()
- [Row(name=u'Bob', age=5)]
- >>> df.where(df.age == 2).collect()
- [Row(name=u'Alice', age=2)]
- >>> df.filter("age > 3").collect()
- [Row(name=u'Bob', age=5)]
- >>> df.where("age = 2").collect()
- [Row(name=u'Alice', age=2)]

3.68 withColumn(colName, col)
通过添加列或替换具有相同名称的现有列来返回新的DataFrame。
参数:● colName – 字符串,新列的名称
● col – 新列的列表达式
- >>> df.withColumn('age2', df.age + 2).collect()
- [Row(name=u'Alice', age=2, age2=4), Row(name=u'Bob', age=5, age2=7)]
3.69 withColumnRenamed(existing, new)
通过重命名现有列来返回新的DataFrame。
参数:● existing – 字符串,要重命名的现有列的名称
● col – 字符串,列的新名称
- >>> df.withColumnRenamed('age', 'age2').collect()
- [Row(name=u'Alice', age2=2), Row(name=u'Bob', age2=5)]
3.70 write
用于将DataFrame的内容保存到外部存储的接口。
返回:DataFrameWriter
转自:http://www.cnblogs.com/wonglu/p/7784825.html
datafram 操作集锦的更多相关文章
- Eclipse for Java EE软件操作集锦(二)
看本文章之前请确保已经了解eclipse建立web工程,如果有疑问请查看本系列文章第一篇 eclipse软件操作集锦(一) 1.我们添加一个servlet 配置一下web.xml测试一下是否能正常显示 ...
- delphi关于文件操作集锦
关于文件操作集锦 取得该快捷方式的指向EXE关键词:快捷方式 LNK unit Unit1; interface usesWindows, Messages, SysUtils, Varian ...
- Eclipse for Java EE软件操作集锦(一)
以下是我在Java网站开发过程中,关于软件操作Eclipse中,遇到的一些问题并提供了解决方案.一.java web开发使用的集成开发工具是eclipse for Java EE 官方下载地址:htt ...
- php数组操作集锦- 掌握了数组操作, 也就掌握了php
参考下面的文章, 是很好的: http://www.cnblogs.com/staven/p/5142515.html http://pcwanli.blog.163.com/blog/static/ ...
- php字符串操作集锦
web操作, 主要就是对字符文本信息进行处理, 所以, 字符串操作几乎占了很大一部分的php操作.包括 注意strstr 和 strtr的区别? 前者表示字符串查找返回字符串,后者表示字符串中字符替换 ...
- XML文档操作集锦(C#篇)
在JSON没流行起来的时候xml一直作为程序存储配置信息的主流介质:特别是小型数据表方面还是不错的选择,所以经常涉及到的操作无非也就是增删改查,这篇博客主要是对这些对比较常用的操作做了个简单的总结 文 ...
- Microsoft Dynamics CRM 2011/2013 JS操作集锦
1.Xrm.Page.context用户ID:getUserId()用户角色:getUserRoles()用户语言:getUserLcid()组织名称:getOrgUniqueName()组织语言:g ...
- sql语句操作集锦
SQL操作全集 下列语句部分是Mssql语句,不可以在access中使用. SQL分类: DDL—数据定义语言(CREATE,ALTER,DROP,DECLARE) DML—数据操纵语言(SELECT ...
- emacs 操作集锦
1.C-k 的功能并不是剪切当前行,而是剪切当前行从光标到行末的内容. Emacs 中的剪切不叫剪切(cut),叫kill,复制(copy)不叫copy ,叫kill-ring-save (这个可以理 ...
随机推荐
- [转帖]Docker Hub上镜像发现挖矿蠕虫病毒,已导致2000台主机感染
Docker Hub上镜像发现挖矿蠕虫病毒,已导致2000台主机感染 https://www.kubernetes.org.cn/5951.html 本来想说可以用 official版本的镜像 但是一 ...
- WUSTOJ 1305: 最短路(Java)
题目链接:
- Android Manifest 中 uses-feature 和 uses-permission的作用 关系和区别
Manifest中的 <uses-permission android:name="android.permission.CAMERA" /> 和 <uses-f ...
- 生成ftp文件的目录树
依赖 <dependency> <groupId>commons-net</groupId> <artifactId>commons-net</a ...
- Spring的事件监听ApplicationListener
ApplicationListener是Spring事件机制的一部分,与抽象类ApplicationEvent类配合来完成ApplicationContext的事件机制. 如果容器中存在Applica ...
- 匹配script标签及内容js代码的正则表达式
<script>[\s\S]+?</script>
- Make Square CodeForces - 1028H (dp)
大意: 若一个序列存在两个数的积为完全平方数, 则为好序列. 给定序列$a$, 每次询问求子区间$[l,r]$最少修改多少次可以成为好序列, 每次修改可以任选素数$p$, 任选一个数乘或除$p$. $ ...
- nginx buffer
1.错误日志:warn:an upstream response is buffered to a temporary file 解决办法:增加fastcgi_buffers 8 4K; fa ...
- [NOIP11.1模拟赛]补番报告
Preface 昨天开始补某科学的超电磁炮S 感觉今天就好了点,炮姐赛高 T1 一开始一直想欧拉定理&ex欧拉定理,结果估计70分,数组开小了GG,看了正解发现是我学傻了 T2 一看就是数据结 ...
- 图片预先加载 preloadjs
<body><div class="loading"> <div class="progress"></div> ...