DataFrame介绍：

DataFrame是一个通过列组织起来的分布式数据集合，它类似传统数据库的一个表，DataFrame包含带schema的行。SparkSQL编程模型可以分为SQL和DataFrame两种。可以通过SparkSession创建。其中的一列可以这样表示 df.age ,df为创建的DataFrame。包的位置 pyspark.sql.dataframe.DataFrame

DataFrame的使用

rdd

开始支持的版本 （1.3）
描述：返回一个pyspark.RDD 类型 每一条数据 class Row
参数：无

na

开始支持的版本 （1.3.1）
描述：返回一个 DataFrameNAFunction 处理缺失值
参数：无

stat

开始支持的版本 （1.4）
描述：返回一个DataFrame 统计函数 参数：无

toJSON

开始支持的版本 （1.3）
描述：把DataFrame转化为一个RDD字符串，每一行json数据对应RDD的每一条Row
参数： use_unicode：编码格式 默认为True
例子：

In [5]: df.toJSON().first()
Out[5]: '{"label":0.0,"features":{"type":0,"size":692,"indices":[127,128,129,130,131,154,155,156,157,158,159,181,182,183,184,185,186,187,188,189,207,208,209,210,211,212,213,214,215,216,217,235,236,237,238,239,240,241,242,243,244,245,262,263,264,265,266,267,268,269,270,271,272,273,289,290,291,292,293,294,295,296,297,300,301,302,316,317,318,319,320,321,328,329,330,343,344,345,346,347,348,349,356,357,358,371,372,373,374,384,385,386,399,400,401,412,413,414,426,427,428,429,440,441,442,454,455,456,457,466,467,468,469,470,482,483,484,493,494,495,496,497,510,511,512,520,521,522,523,538,539,540,547,548,549,550,566,567,568,569,570,571,572,573,574,575,576,577,578,594,595,596,597,598,599,600,601,602,603,604,622,623,624,625,626,627,628,629,630,651,652,653,654,655,656,657],"values":[51.0,159.0,253.0,159.0,50.0,48.0,238.0,252.0,252.0,252.0,237.0,54.0,227.0,253.0,252.0,239.0,233.0,252.0,57.0,6.0,10.0,60.0,224.0,252.0,253.0,252.0,202.0,84.0,252.0,253.0,122.0,163.0,252.0,252.0,252.0,253.0,252.0,252.0,96.0,189.0,253.0,167.0,51.0,238.0,253.0,253.0,190.0,114.0,253.0,228.0,47.0,79.0,255.0,168.0,48.0,238.0,252.0,252.0,179.0,12.0,75.0,121.0,21.0,253.0,243.0,50.0,38.0,165.0,253.0,233.0,208.0,84.0,253.0,252.0,165.0,7.0,178.0,252.0,240.0,71.0,19.0,28.0,253.0,252.0,195.0,57.0,252.0,252.0,63.0,253.0,252.0,195.0,198.0,253.0,190.0,255.0,253.0,196.0,76.0,246.0,252.0,112.0,253.0,252.0,148.0,85.0,252.0,230.0,25.0,7.0,135.0,253.0,186.0,12.0,85.0,252.0,223.0,7.0,131.0,252.0,225.0,71.0,85.0,252.0,145.0,48.0,165.0,252.0,173.0,86.0,253.0,225.0,114.0,238.0,253.0,162.0,85.0,252.0,249.0,146.0,48.0,29.0,85.0,178.0,225.0,253.0,223.0,167.0,56.0,85.0,252.0,252.0,252.0,229.0,215.0,252.0,252.0,252.0,196.0,130.0,28.0,199.0,252.0,252.0,253.0,252.0,252.0,233.0,145.0,25.0,128.0,252.0,253.0,252.0,141.0,37.0]},"rawPrediction":{"type":1,"values":[0.7376543954891018,-0.7376543954891018]},"probability":{"type":1,"values":[0.6764827243160599,0.32351727568394006]},"prediction":0.0}'

registerTempTable

开始支持的版本 （1.3）
描述：把DataFrame注册临时表，临时表的生存时间取决于创建此DataFrame的SparkSession
参数：
name：临时表的名称
例子：

In [6]: df.registerTempTable("people")
In [7]: df2 = spark.sql("select * from people")
In [8]: sorted(df.collect()) == sorted(df2.collect())
Out[8]: True
In [9]: spark.catalog.dropTempView("people")

createTempView

开始支持的版本 （2.0）
描述：把DataFrame注册临时视图，临时视图的生存时间取决于创建此DataFrame的SparkSession，如果此视图的name已经存在抛出TempTableAlreadyExistsException的异常
参数： name：视图名称
例子：

In[10]: df.createTempView("people")
In[11]: df2 = spark.sql("select * from people")
In[12]: sorted(df.collect()) == sorted(df2.collect())
Out[12]: True
In[13]:  df.createTempView("people")  # doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
AnalysisException: u"Temporary table 'people' already exists;"
In[14]: spark.catalog.dropTempView("people")

createOrReplaceTempView

开始支持的版本 （2.0）
描述：创建或者替换视图，和 createTempView一样只是视图名称存在时不会抛出异常会取代之前的视图
参数：name：视图名称
例子：

In[15]: df.createOrReplaceTempView("people")
In[16]: df2 = df.filter(df.age > 3)
In[17]: df2.createOrReplaceTempView("people")
In[18]: df3 = spark.sql("select * from people")
In[19]: sorted(df3.collect()) == sorted(df2.collect())
Out[19]: True
In[20]: spark.catalog.dropTempView("people")

createGlobalTempView

开始支持的版本 （2.1）
描述：为DataFrame创建一个全局视图，此视图的生命周期取决于此Spark application，已存在是会抛出异常
参数：name：视图名称
例子：

In[21]: df.createGlobalTempView("people")
In[22]: df2 = spark.sql("select * from global_temp.people")
In[23]: sorted(df.collect()) == sorted(df2.collect())
Out[23]: True
In[24]: df.createGlobalTempView("people")  # doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
AnalysisException: u"Temporary table 'people' already exists;"
In[25]: spark.catalog.dropGlobalTempView("people")

createOrReplaceGlobalTempView

开始支持的版本 （2.2）
描述：为DataFrame创建活替换一个全局视图，此视图的生命周期取决于此Spark application，已存在不会抛出一样 会取代之前的视图
参数：name：视图名称
例子：

In[25]: df.createOrReplaceGlobalTempView("people")
In[26]: df2 = df.filter(df.age > 3)
In[27]: df2.createOrReplaceGlobalTempView("people")
In[28]: df3 = spark.sql("select * from global_temp.people")
In[29]: sorted(df3.collect()) == sorted(df2.collect())
Out[29]: True
In[30]: spark.catalog.dropGlobalTempView("people")

write

开始支持的版本 （1.4）
描述：用于把非streaming的DataFrame保存到外部存储，返回一个DataFrameWriter
参数：无

writeStream

开始支持的版本 （2.0）
描述：用于把streaming的DataFrame保存到外部存储，返回一个DataStreamWriter
参数：无

schema

开始支持的版本 （1.3）
描述：返回这个DataFrame的schema 类型 pyspark.sql.types.StructType
参数：无
例子：

In[31]: df.schema
Out[31]: StructType(List(StructField(age,IntegerType,true),StructField(name,StringType,true)))

printSchema

开始支持的版本 （1.3）
描述：以树状格式输出打印schema
参数：无
例子：

In [14]: df.printSchema()
root
 |-- label: double (nullable = true)
 |-- features: vector (nullable = true)
 |-- rawPrediction: vector (nullable = true)
 |-- probability: vector (nullable = true)
 |-- prediction: double (nullable = false)

explain

开始支持的版本 （1.3）
描述：打印（逻辑或物理）计划到控制台
参数：extended：默认False boolean类型
如果为False 只打印物理计划，当未指定模式为物理l计划
mode：预输出格式
“simple”只打印物理计划
“extended”：物理和逻辑计划都打印
“codegen”:如果generated和physical plan都存在，打印他们两个
“cost”:如果statistics和logical plan 都存在，打印他们两个
“formatted”:将输出切分为两部分，一个physical plan outline 一个node derails
物理计划是Spark和Sparksql相对比而言的，因为SparkSql是在Spark core上的一个抽象，物理化就是变成RDD，是SparkSql和Spark core之间的衔接点。
Physical Plan也是Catalyst变成Spark作业的最后一个阶段。
例子：

>>> df.explain()
== Physical Plan ==
*(1) Scan ExistingRDD[age#0,name#1]

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

>>> df.explain(mode="formatted")
== Physical Plan ==
* Scan ExistingRDD (1)
(1) Scan ExistingRDD [codegen id : 1]
Output [2]: [age#0, name#1]
...

>>> df.explain("cost")
== Optimized Logical Plan ==
...Statistics...
...

exceptAll

开始支持的版本 （2.4）
描述：返回一个新的DataFrame，包含这个DataFrame的row但不在另一个DataFrame的ow中，也作为SQL的标准，解决按列的位置而不是通过name
参数：other：其他DataFrame
例子：

>>> df1 = spark.createDataFrame(
...         [("a", 1), ("a", 1), ("a", 1), ("a", 2), ("b",  3), ("c", 4)], ["C1", "C2"])
>>> df2 = spark.createDataFrame([("a", 1), ("b", 3)], ["C1", "C2"])

>>> df1.exceptAll(df2).show()
+---+---+
| C1| C2|
+---+---+
|  a|  1|
|  a|  1|
|  a|  2|
|  c|  4|
+---+---+

isLocal

开始支持的版本 （1.3）
描述：如果function collect 或者take方法可以在本地运行则返回True
参数：无

isStreaming

开始支持的版本 （2.0）
描述：当这个Dataset包含一个或多个当数据到达时连续不断的返回数据的数据源，此方法返回True。一个Dataset读取流数据必须在DataStreamWriter中使用start()方法执行一个StreamingQuery。

show

开始支持的版本 （1.3）
描述：在控制台打印前n行
参数：n： 打印前n行 默认为20
truncate:默认为True ,截取值长度超过20的字符串，如果设置的字符超过这个数字，截取这个字符串并右对齐
vertical：垂直打印每个row数据
例子：

In [7]: df.show()
+-----+--------------------+--------------------+--------------------+----------+
|label|            features|       rawPrediction|         probability|prediction|
+-----+--------------------+--------------------+--------------------+----------+
|  0.0|(692,[127,128,129...|[0.73765439548910...|[0.67648272431605...|       0.0|
|  1.0|(692,[158,159,160...|[-1.2286964884747...|[0.22640965216205...|       1.0|
|  1.0|(692,[124,125,126...|[-1.2596645795726...|[0.22103163838284...|       1.0|
|  1.0|(692,[152,153,154...|[-1.0845333752697...|[0.25264907653471...|       1.0|
|  1.0|(692,[151,152,153...|[-1.2371063245185...|[0.22494007343582...|       1.0|
|  0.0|(692,[129,130,131...|[0.73839617859787...|[0.67664504514663...|       0.0|
|  1.0|(692,[158,159,160...|[-1.2123284339889...|[0.22928932070495...|       1.0|
|  1.0|(692,[99,100,101,...|[-0.2350856805053...|[0.44149776057216...|       1.0|
|  0.0|(692,[154,155,156...|[0.10357406008713...|[0.52587039191803...|       0.0|
|  0.0|(692,[127,128,129...|[0.72217476589208...|[0.67308573545409...|       0.0|
|  1.0|(692,[154,155,156...|[-1.2846773150663...|[0.21675509297450...|       1.0|
|  0.0|(692,[153,154,155...|[0.58973239143557...|[0.64330374150786...|       0.0|
|  0.0|(692,[151,152,153...|[0.79440962997833...|[0.68877737853447...|       0.0|
|  1.0|(692,[129,130,131...|[-1.1368414333293...|[0.24290074953354...|       1.0|
|  0.0|(692,[154,155,156...|[0.15716760452388...|[0.53921121917109...|       0.0|
|  1.0|(692,[150,151,152...|[-1.2672409981625...|[0.21972991351452...|       1.0|
|  0.0|(692,[124,125,126...|[0.51726738112397...|[0.62650856693635...|       0.0|
|  0.0|(692,[152,153,154...|[0.52858890132176...|[0.62915393551335...|       0.0|
|  1.0|(692,[97,98,99,12...|[-1.1867285064582...|[0.23384455029876...|       1.0|
|  1.0|(692,[124,125,126...|[-1.1960805426348...|[0.23217319989063...|       1.0|
+-----+--------------------+--------------------+--------------------+----------+

In [9]: df.show(truncate=3)
+-----+--------+-------------+-----------+----------+
|label|features|rawPrediction|probability|prediction|
+-----+--------+-------------+-----------+----------+
|  0.0|     (69|          [0.|        [0.|       0.0|
|  1.0|     (69|          [-1|        [0.|       1.0|
|  1.0|     (69|          [-1|        [0.|       1.0|
|  1.0|     (69|          [-1|        [0.|       1.0|
|  1.0|     (69|          [-1|        [0.|       1.0|
|  0.0|     (69|          [0.|        [0.|       0.0|
|  1.0|     (69|          [-1|        [0.|       1.0|
|  1.0|     (69|          [-0|        [0.|       1.0|
|  0.0|     (69|          [0.|        [0.|       0.0|
|  0.0|     (69|          [0.|        [0.|       0.0|
|  1.0|     (69|          [-1|        [0.|       1.0|
|  0.0|     (69|          [0.|        [0.|       0.0|
|  0.0|     (69|          [0.|        [0.|       0.0|
|  1.0|     (69|          [-1|        [0.|       1.0|
|  0.0|     (69|          [0.|        [0.|       0.0|
|  1.0|     (69|          [-1|        [0.|       1.0|
|  0.0|     (69|          [0.|        [0.|       0.0|
|  0.0|     (69|          [0.|        [0.|       0.0|
|  1.0|     (69|          [-1|        [0.|       1.0|
|  1.0|     (69|          [-1|        [0.|       1.0|
+-----+--------+-------------+-----------+----------+

In [7]: df.show(vertical=True)
-RECORD 0-----
 age  | 2
 name | Alice
-RECORD 1-----
 age  | 5
 name | Bob

checkpoint

开始支持的版本 （2.1）
描述：返回数据集的checkpoint版本

localCheckpoint

开始支持的版本 （2.3）
描述：返回本地数据集的checkpoint版本

withWatermark

开始支持的版本 （2.1）
描述:为这个DataFrame定设置一个时间水印，水印跟踪这个点之前，没有更多的数据进来。
就是设置一个时间戳，和一个延迟时间，从这个时间戳开始算，比这个延迟时间之后的数据就不加入统计计算了。
参数：eventTime：时间戳字段名 delayThreshold：等待时间，例："1 minute" or "5 hours"

hint

开始支持的版本 （2.2）
描述：spark SQL 查询提示

count

开始支持的版本 （1.3）
描述：返回DataFrame的行数
参数：无
例子：

In [17]: df.count()
Out[17]: 100

collect

开始支持的版本 （1.3）
描述：以list形式返回所有记录，元素是每一行
参数：无
例子：

>>> df.collect()
[Row(age=2, name=u'Alice'), Row(age=5, name=u'Bob')]

toLocalIterator

开始支持的版本 （2.0）
描述：返回一个包含DataFrame所有Row的迭代器，迭代器将使用尽可能多的内存在这个DataFrame最大的分区 通过预读数据，他可能超过2个最大内存分区

>>> list(df.toLocalIterator())
[Row(age=2, name=u'Alice'), Row(age=5, name=u'Bob')]

limit

开始支持的版本 （1.3）
描述：限制返回结果的数量
例子：

In [33]: df1.limit(1).show()
+-----+----------+-----+
|label|prediction|count|
+-----+----------+-----+
| null|       1.0|   59|
+-----+----------+-----+


In [34]: df1.show()
+-----+----------+-----+
|label|prediction|count|
+-----+----------+-----+
| null|       1.0|   59|
| null|      null|  100|
|  0.0|       1.0|    2|
|  0.0|      null|   43|
|  0.0|       0.0|   41|
|  1.0|       1.0|   57|
|  1.0|      null|   57|
| null|       0.0|   41|
+-----+----------+-----+

take

开始支持的版本 （1.3）
描述:返回第一行到第n行的数据，返回一个list
例子：

In [16]: df2.take(3)
Out[16]:
[Row(label=None, prediction=None, count=100),
 Row(label=0.0, prediction=1.0, count=2),
 Row(label=0.0, prediction=None, count=43)]

tail

开始支持的版本 （3.0）
描述：返回最后n行的数据，返回一个list
例子：

In [17]: df2.tail(3)
Out[17]:
[Row(label=0.0, prediction=0.0, count=41),
 Row(label=1.0, prediction=1.0, count=57),
 Row(label=1.0, prediction=None, count=57)]

foreach

开始支持的版本 （1.3）
描述：遍历DataFrame，参数f适用DataFrame的所有行，这是df.rdd.foreach()的缩写一般用来打印DataFrame
例子：

In [31]: df2.foreach(lambda x: print(x))
Row(label=0.0, prediction=0.0, count=41)                          (0 + 8) / 200]
Row(label=1.0, prediction=1.0, count=57)
Row(label=1.0, prediction=None, count=57)
Row(label=0.0, prediction=None, count=43)
Row(label=None, prediction=None, count=100)
Row(label=0.0, prediction=1.0, count=2)
In [32]: def f(dd):
    ...:     print(dd)
    
In [33]: df2.foreach(f)
Row(label=0.0, prediction=1.0, count=2)                           (0 + 8) / 200]
Row(label=1.0, prediction=None, count=57)
Row(label=0.0, prediction=None, count=43)
Row(label=1.0, prediction=1.0, count=57)
Row(label=None, prediction=None, count=100)
Row(label=0.0, prediction=0.0, count=41)

foreachPartition

开始支持的版本 （1.3）
描述：遍历DataFrame每个分区，参数f适用DataFrame的每个分区，这是df.rdd.foreachPartition()的缩写

cache

开始支持的版本 （1.3）
描述：根据默认的存储级别持久化(MEMORY_AND_DISK).

persist

开始支持的版本 （1.3）
描述：　设置存储级别，以在首次计算存储级别后在所有操作中持久保存其值。如果RDD尚未设置存储级别，则只能用于分配新的存储级别。如果没有设置默认为MEMORY_AND_DISK

storageLevel

开始支持的版本 （2.1）
描述：获取DataFrame的存储级别
例子：

In [18]: df.storageLevel
Out[18]: StorageLevel(False, False, False, False, 1)

五个分别代表：useDisk、useMemory、useOffHeap、deserialized、replication

unpersist

开始支持的版本 （1.3）
描述：标志这个DataFrame为非持久性，并且从内存和磁盘中删除所有blocks

coalesce

开始支持的版本 （1.4）
描述：返回一个恰好有numpartition分区数的新的DataFrame，用来合并分区即减少分区
参数：numPartitions：分区数
例子：

>>> df.coalesce(1).rdd.getNumPartitions()
1

repartition

开始支持的版本 （1.3）
描述：返回一个新的DataFrame，这个DataFrame以给定的分区表达式分区。这个结果DataFrame是被散列分区的
参数：numPartitions可以是一个int指定目标分区的数量或者是一个Column。如果是一个Column，他将被用作第一个分区的column。如果没有指定，将使用默认的分区数
例子：

>>> df.repartition(10).rdd.getNumPartitions()
10
>>> data = df.union(df).repartition("age")
>>> data.show()
+---+-----+
|age| name|
+---+-----+
|  5|  Bob|
|  5|  Bob|
|  2|Alice|
|  2|Alice|
+---+-----+
>>> data = data.repartition(7, "age")
>>> data.show()
+---+-----+
|age| name|
+---+-----+
|  2|Alice|
|  5|  Bob|
|  2|Alice|
|  5|  Bob|
+---+-----+
>>> data.rdd.getNumPartitions()
7
>>> data = data.repartition("name", "age")
>>> data.show()
+---+-----+
|age| name|
+---+-----+
|  5|  Bob|
|  5|  Bob|
|  2|Alice|
|  2|Alice|
+---+-----+

repartitionByRange

开始支持的版本 （2.4.0）
同上，至少指定一个通过表达式的分区，当没有指定的时候，则ascending nulls first

distinct

开始支持的版本 （1.3）
描述：返回一个包含不同行的新的DataFrame，也就是对DataFrame中的行进行去重
例子：

 df.distinct().show()
+-----+--------------------+--------------------+--------------------+----------+
|label|            features|       rawPrediction|         probability|prediction|
+-----+--------------------+--------------------+--------------------+----------+
|  0.0|(692,[127,128,129...|[0.69397458939766...|[0.66685050993452...|       0.0|
|  0.0|(692,[152,153,154...|[0.15102231211268...|[0.53768398137283...|       0.0|
|  1.0|(692,[129,130,131...|[-1.2787335270409...|[0.21776588240928...|       1.0|
|  0.0|(692,[234,235,237...|[0.23761746265120...|[0.55912642712453...|       0.0|
|  1.0|(692,[126,127,128...|[-1.2908889149456...|[0.21570239074898...|       1.0|
|  1.0|(692,[129,130,131...|[-1.2194066238265...|[0.22804089061513...|       1.0|
|  1.0|(692,[129,130,131...|[-1.0102453843227...|[0.26693183140005...|       1.0|
|  0.0|(692,[126,127,128...|[0.52654941724023...|[0.62867795938410...|       0.0|
|  1.0|(692,[124,125,126...|[-1.1917346121564...|[0.23294884532110...|       1.0|
|  1.0|(692,[150,151,152...|[-1.2672409981625...|[0.21972991351452...|       1.0|

sample

开始支持的版本 （1.3）
描述：返回这个DataFrame抽样后的子集
参数：
withReplacement：替换样品 是否可以多次抽样 默认false
fraction ：[0.0,1.0]之间 期望样本大小，当withReplacement=false时：选择每个元素的概率;分数一定是[0,1] ；当withReplacement=true时：选择每个元素的期望次数; 分数必须大于等于0。
seed：随机数生成器的种子

sampleBy

开始支持的版本 （1.5）
描述：设置列的权重即 抽中概率进行抽样
参数：
col:抽样的列
fractions:抽中每个值的概率，如果没设置为0
seed:随机数生成器的种子
例子：

>>> 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|    3|
|  1|    6|
+---+-----+
>>> dataset.sampleBy(col("key"), fractions={2: 1.0}, seed=0).count()
33

randomSplit

开始支持的版本 （1.4）
描述：根据提供的权重随机拆分DataFrame
参数：weights：list of doubles list中的数据相加应该等于1，如果不等于增会被标准化
seed:可选参数 random的种子

dtypes

开始支持的版本 （1.3）
描述：以一个list形式返回所有列名和数据类型
参数：无
例子：

In [46]: df.dtypes
Out[46]:
[('label', 'double'), ('features', 'vector'), ('rawPrediction', 'vector'), ('probability', 'vector'), ('prediction', 'double')]

columns

开始支持的版本 （1.3）
描述：以list形式返回所有的列的name
例子：

In [12]: df.columns
Out[12]: ['label', 'features', 'rawPrediction', 'probability', 'prediction']

colRegex

开始支持的版本 （2.3）
描述：用正则表达式的方式返回我们想要的列
参数：colName：正则表达式列名
例子：

In [11]: df.select(df.colRegex("`(pr)+.+`")).show()
+--------------------+----------+
|         probability|prediction|
+--------------------+----------+
|[0.67648272431605...|       0.0|
|[0.22640965216205...|       1.0|
|[0.22103163838284...|       1.0|
|[0.25264907653471...|       1.0|
|[0.22494007343582...|       1.0|
|[0.67664504514663...|       0.0|
|[0.22928932070495...|       1.0|
|[0.44149776057216...|       1.0|
|[0.52587039191803...|       0.0|
|[0.67308573545409...|       0.0|
|[0.21675509297450...|       1.0|
|[0.64330374150786...|       0.0|
|[0.68877737853447...|       0.0|
|[0.24290074953354...|       1.0|
|[0.53921121917109...|       0.0|
|[0.21972991351452...|       1.0|
|[0.62650856693635...|       0.0|
|[0.62915393551335...|       0.0|
|[0.23384455029876...|       1.0|
|[0.23217319989063...|       1.0|
+--------------------+----------+
only showing top 20 rows

alias

开始支持的版本 （1.3）
描述：返回一个设置别名的新DataFrame
参数：alias：类型String ，DataFrame被设置的别名

crossJoin

开始支持的版本 （2.1）
描述：返回一个笛卡尔积的DataFrame
例子：

>>> df.select("age", "name").collect()
[Row(age=2, name=u'Alice'), Row(age=5, name=u'Bob')]
>>> df2.select("name", "height").collect()
[Row(name=u'Tom', height=80), Row(name=u'Bob', height=85)]
>>> df.crossJoin(df2.select("height")).select("age", "name", "height").collect()
[Row(age=2, name=u'Alice', height=80), Row(age=2, name=u'Alice', height=85),
 Row(age=5, name=u'Bob', height=80), Row(age=5, name=u'Bob', height=85)]

join

开始支持的版本 （1.3）
描述：根据给定的join表达式与别的DataFrame join
参数：
other：join的右边
on：join列的名称，类型 string 或list, on包含的列必须在两边都存在
how: 类型 string 必须是inner, cross, outer, full, fullouter, full_outer, left, leftouter, left_outer, right, rightouter, right_outer, semi, leftsemi, left_semi, anti, leftanti and left_anti这些中的值 默认为inner
例子：

>>> from pyspark.sql.functions import desc
>>> df.join(df2, df.name == df2.name, 'outer').select(df.name, df2.height) \
        .sort(desc("name")).collect()
[Row(name=u'Bob', height=85), Row(name=u'Alice', height=None), Row(name=None, height=80)]

>>> df.join(df2, 'name', 'outer').select('name', 'height').sort(desc("name")).collect()
[Row(name=u'Tom', height=80), Row(name=u'Bob', height=85), Row(name=u'Alice', height=None)]

>>> cond = [df.name == df3.name, df.age == df3.age]
>>> df.join(df3, cond, 'outer').select(df.name, df3.age).collect()
[Row(name=u'Alice', age=2), Row(name=u'Bob', age=5)]

>>> df.join(df2, 'name').select(df.name, df2.height).collect()
[Row(name=u'Bob', height=85)]

>>> df.join(df4, ['name', 'age']).select(df.name, df.age).collect()
[Row(name=u'Bob', age=5)]

sortWithinPartitions

开始支持的版本 （1.6）
描述：给每个分区的指定列排序
sort
开始支持的版本 （1.3）
描述：根据指定列排序返回一个新的DataFrame
参数：cols：类型 list 或string ascending：bool 或 list bool默认为True
例子：

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

describe

开始支持的版本 （1.3.1）
描述：计算，统计数值型的列包括 计数count, 平均值mean, 标准差stddev, 最小值min, 最大值max。如果cols给定，那么这个函数计算统计所有数值型的列。
例子：

In [35]: df.describe().show()
+-------+-------------------+------------------+
|summary|              label|        prediction|
+-------+-------------------+------------------+
|  count|                100|               100|
|   mean|               0.57|              0.59|
| stddev|0.49756985195624287|0.4943110704237104|
|    min|                0.0|               0.0|
|    max|                1.0|               1.0|
+-------+-------------------+------------------+

summary

开始支持的版本 （2.3）
描述：计算数值列和字符串列的统计信息，包括count、mean、stddev、min、max、按一定百分比的近似百分位数
例子：

>>> df.summary().show()
+-------+------------------+-----+
|summary|               age| name|
+-------+------------------+-----+
|  count|                 2|    2|
|   mean|               3.5| null|
| stddev|2.1213203435596424| null|
|    min|                 2|Alice|
|    25%|                 2| null|
|    50%|                 2| null|
|    75%|                 5| null|
|    max|                 5|  Bob|
+-------+------------------+-----+

>>> df.summary("count", "min", "25%", "75%", "max").show()
+-------+---+-----+
|summary|age| name|
+-------+---+-----+
|  count|  2|    2|
|    min|  2|Alice|
|    25%|  2| null|
|    75%|  5| null|
|    max|  5|  Bob|
+-------+---+-----+

head

开始支持的版本 （1.3）
描述：返回前n行
参数：n 类型 int
例子：

In [25]: df1.head(3)
Out[25]:
[Row(label=None, prediction=1.0, count=59),
 Row(label=None, prediction=None, count=100),
 Row(label=0.0, prediction=1.0, count=2)]

first

开始支持的版本 （1.3）
描述：返回第一行Row
例子：

In [30]: df2.first()
Out[30]: Row(label=None, prediction=None, count=100)

select

开始支持的版本 （1.3）
描述：通过查询表达式返回一个新的DataFrame
例子：

>>> df.select('*').collect()
[Row(age=2, name=u'Alice'), Row(age=5, name=u'Bob')]
>>> 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)]

selectExpr

开始支持的版本 （1.3）
描述：select的变体 接受sql表达式

filter

开始支持的版本 （1.3）
描述：根据给定的condition过滤rows
where是filter的别名
参数：condition：筛选条件

In [26]: df2.show()
+-----+----------+-----+
|label|prediction|count|
+-----+----------+-----+
| null|      null|  100|
|  0.0|       1.0|    2|
|  0.0|      null|   43|
|  0.0|       0.0|   41|
|  1.0|       1.0|   57|
|  1.0|      null|   57|
+-----+----------+-----+
In [27]: df2.filter(df2.label>0).show()
+-----+----------+-----+
|label|prediction|count|
+-----+----------+-----+
|  1.0|       1.0|   57|
|  1.0|      null|   57|
+-----+----------+-----+
In [28]: df2.filter("label>0").show()
+-----+----------+-----+
|label|prediction|count|
+-----+----------+-----+
|  1.0|       1.0|   57|
|  1.0|      null|   57|
+-----+----------+-----+

groupBy

开始支持的版本 （1.3）
描述：根据指定的columns Groups the DataFrame，这样可以在DataFrame上进行聚合。从所有可用的聚合函数中查看GroupedData，groupby()是groupBy()的一个别名。
参数：cols: 要group的列 类型 list
例子：

In [24]: df.groupBy().avg().show()
+----------+---------------+
|avg(label)|avg(prediction)|
+----------+---------------+
|      0.57|           0.59|
+----------+---------------+
>>> sorted(df.groupBy('name').agg({'age': 'mean'}).collect())
[Row(name=u'Alice', avg(age)=2.0), Row(name=u'Bob', avg(age)=5.0)]
>>> sorted(df.groupBy(df.name).avg().collect())
[Row(name=u'Alice', avg(age)=2.0), Row(name=u'Bob', avg(age)=5.0)]
>>> sorted(df.groupBy(['name', df.age]).count().collect())
[Row(name=u'Alice', age=2, count=1), Row(name=u'Bob', age=5, count=1)

rollup

开始支持的版本 （1.4）
描述：使用当前DataFrame给定的cols创建一个多维的rollup，这样我们可以在其上进行聚合
例子：

>>> df.rollup("name", df.age).count().orderBy("name", "age").show()
+-----+----+-----+
| name| age|count|
+-----+----+-----+
| null|null|    2|
|Alice|null|    1|
|Alice|   2|    1|
|  Bob|null|    1|
|  Bob|   5|    1|
+-----+----+-----+

cube

开始支持的版本 （1.4）
描述：当前DataFrame使用指定的columns创建一个多维立方体为，这样我们可以在其上运行聚合
与rollup 的区别 cube分的更细分组更多 详细参考 www.jianshu.com/p/aa09aa436…
例子：

In [18]: df1 = df.cube("label",df.prediction).count()

In [19]: df1.show()
+-----+----------+-----+
|label|prediction|count|
+-----+----------+-----+
| null|       1.0|   59|
| null|      null|  100|
|  0.0|       1.0|    2|
|  0.0|      null|   43|
|  0.0|       0.0|   41|
|  1.0|       1.0|   57|
|  1.0|      null|   57|
| null|       0.0|   41|
+-----+----------+-----+

agg

开始支持的版本 （1.3）
描述：没有组的情况下聚集整个DataFrame，df.groupBy.agg()的简写
例子：

>>> 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)]

union

开始支持的版本 （2.0）
描述：返回一个新的DataFrame，包含本frame与other frame行的并集

unionAll

开始支持的版本 （1.3）
描述：和union一样

unionByName

开始支持的版本 （2.3）
描述：通过列名进行union操作取并集
例子：

In [50]: df4.union(df5).show()
+----+----+----+
|col0|col1|col2|
+----+----+----+
|   1|   2|   3|
|   4|   5|   6|
+----+----+----+


In [51]: df4.unionByName(df5).show()
+----+----+----+
|col0|col1|col2|
+----+----+----+
|   1|   2|   3|
|   6|   4|   5|
+----+----+----+

intersect

开始支持的版本 （1.3）
描述：返回一个新的DataFrame，新的DataFrame中的row是这个DataFrame与另一个DataFrame共有的row。这个函数也就是求交集
例子：

In [28]: df1.show()
+-----+----------+-----+
|label|prediction|count|
+-----+----------+-----+
| null|       1.0|   59|
| null|      null|  100|
|  0.0|       1.0|    2|
|  0.0|      null|   43|
|  0.0|       0.0|   41|
|  1.0|       1.0|   57|
|  1.0|      null|   57|
| null|       0.0|   41|
+-----+----------+-----+


In [29]: df2.show()
+-----+----------+-----+
|label|prediction|count|
+-----+----------+-----+
| null|      null|  100|
|  0.0|       1.0|    2|
|  0.0|      null|   43|
|  0.0|       0.0|   41|
|  1.0|       1.0|   57|
|  1.0|      null|   57|
+-----+----------+-----+


In [30]: df1.intersect(df2).show()
+-----+----------+-----+
|label|prediction|count|
+-----+----------+-----+
|  1.0|       1.0|   57|
| null|      null|  100|
|  0.0|       1.0|    2|
|  0.0|      null|   43|
|  1.0|      null|   57|
|  0.0|       0.0|   41|
+-----+----------+-----+

intersectAll

开始支持的版本 （2.4）
描述：和intersect一样,但是保留重复项

subtract

开始支持的版本 （1.3）
描述：返回一个新的DataFrame，其中包含此DataFrame中的行，但不包含另一个DataFrame中的行。相当于减法

dropDuplicates

开始支持的版本 （1.4）
描述：返回一个新的删除重复行的DataFrame,选择性地只考虑某些列
参数：subset
例子：

In [38]: df.dropDuplicates().show()
+-----+--------------------+--------------------+--------------------+----------+
|label|            features|       rawPrediction|         probability|prediction|
+-----+--------------------+--------------------+--------------------+----------+
|  0.0|(692,[127,128,129...|[0.69397458939766...|[0.66685050993452...|       0.0|
|  0.0|(692,[152,153,154...|[0.15102231211268...|[0.53768398137283...|       0.0|
|  1.0|(692,[129,130,131...|[-1.2787335270409...|[0.21776588240928...|       1.0|
|  0.0|(692,[234,235,237...|[0.23761746265120...|[0.55912642712453...|       0.0|
|  1.0|(692,[126,127,128...|[-1.2908889149456...|[0.21570239074898...|       1.0|
|  1.0|(692,[129,130,131...|[-1.2194066238265...|[0.22804089061513...|       1.0|
|  1.0|(692,[129,130,131...|[-1.0102453843227...|[0.26693183140005...|       1.0|
|  0.0|(692,[126,127,128...|[0.52654941724023...|[0.62867795938410...|       0.0|
|  1.0|(692,[124,125,126...|[-1.1917346121564...|[0.23294884532110...|       1.0|
|  1.0|(692,[150,151,152...|[-1.2672409981625...|[0.21972991351452...|       1.0|
|  0.0|(692,[123,124,125...|[0.81752117294652...|[0.69370990072687...|       0.0|
|  0.0|(692,[152,153,154...|[0.31473184232097...|[0.57803982797152...|       0.0|
|  0.0|(692,[126,127,128...|[0.73006319535312...|[0.67481914021436...|       0.0|
|  1.0|(692,[126,127,128...|[-1.2587222363478...|[0.22119393053746...|       1.0|
|  0.0|(692,[100,101,102...|[-0.2017152859634...|[0.44974147737694...|       1.0|
|  1.0|(692,[129,130,131...|[-1.2863123289797...|[0.21647764141709...|       1.0|
|  0.0|(692,[124,125,126...|[0.35628234650652...|[0.58814019802100...|       0.0|
|  1.0|(692,[100,101,102...|[-1.2906258687264...|[0.21574689488668...|       1.0|
|  0.0|(692,[155,156,180...|[0.55723605361513...|[0.63581277554213...|       0.0|
|  1.0|(692,[126,127,128...|[-1.2925944412562...|[0.21541399846288...|       1.0|
+-----+--------------------+--------------------+--------------------+----------+
only showing top 20 rows


In [39]: df.dropDuplicates().count()
Out[39]: 100

In [40]: df.dropDuplicates(["label","prediction"]).count()
Out[40]: 3

dropna

开始支持的版本 （1.3.1）
描述：返回一个新的省略具有null的行的DataFrame。DataFrame.dropna() 和 DataFrameNaFunctions.drop()是彼此的别名
参数：
how – ‘any’ or ‘all’. 如果‘any’,如果这一行含有任何空值删除这一行。如果是‘all’，只有这一行所有的值是空值才删除这一行。
thresh – int, 如果没有指定默认为None，当这一行包含null值多余thresh时删除此行。这个参数重写how参数。
subset – optional list of column names to consider.
例子：

In [42]: df1.show()
+-----+----------+-----+
|label|prediction|count|
+-----+----------+-----+
| null|       1.0|   59|
| null|      null|  100|
|  0.0|       1.0|    2|
|  0.0|      null|   43|
|  0.0|       0.0|   41|
|  1.0|       1.0|   57|
|  1.0|      null|   57|
| null|       0.0|   41|
+-----+----------+-----+
In [43]: df1.dropna().show()
+-----+----------+-----+
|label|prediction|count|
+-----+----------+-----+
|  0.0|       1.0|    2|
|  0.0|       0.0|   41|
|  1.0|       1.0|   57|
+-----+----------+-----+

fillna

开始支持的版本 （1.3.1）
描述：替换空值na.fill()的别名，DataFrame.fillna() 和 DataFrameNaFunctions.fill()是彼此的别名
例子：

In [25]: df2.fillna(1).show()
+-----+----------+-----+
|label|prediction|count|
+-----+----------+-----+
|  1.0|       1.0|  100|
|  0.0|       1.0|    2|
|  0.0|       1.0|   43|
|  0.0|       0.0|   41|
|  1.0|       1.0|   57|
|  1.0|       1.0|   57|
+-----+----------+-----+
In [26]: df2.show()
+-----+----------+-----+
|label|prediction|count|
+-----+----------+-----+
| null|      null|  100|
|  0.0|       1.0|    2|
|  0.0|      null|   43|
|  0.0|       0.0|   41|
|  1.0|       1.0|   57|
|  1.0|      null|   57|
+-----+----------+-----+

replace

开始支持的版本 （1.4）
描述:替换DataFrame中的值：
参数：
to_replace:要被替换的值 类型bool, int, long, float, string, list or dict. 如果value 是dict 那么value可以省略或者忽略 value:替换的值 类型bool, int, long, float, string, list or None subset:要选择操作的列名
例子：

>>> df4.na.replace(10, 20).show()
+----+------+-----+
| age|height| name|
+----+------+-----+
|  20|    80|Alice|
|   5|  null|  Bob|
|null|  null|  Tom|
|null|  null| null|
+----+------+-----+

>>> df4.na.replace('Alice', None).show()
+----+------+----+
| age|height|name|
+----+------+----+
|  10|    80|null|
|   5|  null| Bob|
|null|  null| Tom|
|null|  null|null|
+----+------+----+

>>> df4.na.replace({'Alice': None}).show()
+----+------+----+
| age|height|name|
+----+------+----+
|  10|    80|null|
|   5|  null| Bob|
|null|  null| Tom|
|null|  null|null|
+----+------+----+

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

approxQuantile

开始支持的版本 （2.0）
描述：计算一个用数值表示的列的DataFrame的近似分位点
有以下限制：如果DataFrame有N个元素，请求分位点的概率为P，错误为err,算法将从DataFrame返回一个样本x,x的精确rank值接近于（P*N），准确的说floor((p - err) * N) <= rank(x) <= ceil((p + err) * N).这种方法实现Greenwald-Khanna算法的一个变体(增加速度优化)，这个算法第一次是由 Greenwald and Khanna提出的 infolab.stanford.edu/~datar/cour…
参数：col:用数表示的列的name
probabilities:分位点概率 范围在[0,1]之间 0是 mininum ，0.5是median， 1是maximum
relativeError:去实现的相对目标精确度 大于等于0 ，如果设置为0 计算精确的分位数是很难的，大于1的时候得到的结果和1是一样的
return：给的精确度的近似分位点

corr

开始支持的版本 （1.4）
描述：计算一个DataFrame中两列的相关性作为一个double值 ，目前只支持皮尔逊相关系数。DataFrame.corr() 和 DataFrameStatFunctions.corr()是彼此的别名。
参数：
col1：第一列列名
col2： 第二列列名
method：相关的方法，目前只支持“pearson”
例子：

In [17]: df.count()
Out[17]: 100

cov

开始支持的版本 （1.4）
描述：计算给定列的协方差，有他们的names指定，作为一个double值。DataFrame.cov() 和 DataFrameStatFunctions.cov()是彼此的别名
参数：col1 col2
例子：

In [20]: df.cov("label","prediction")
Out[20]: 0.23606060606060603

crosstab

开始支持的版本 （1.4）
描述：　由给定的列计算一个双向的频率表.也被称为一个列联表。
每一列的不同值的数量应该小于1e4. 最多1e6 非零对频率将被返回
例子：

In [21]: df.crosstab("label","prediction")
Out[21]: DataFrame[label_prediction: string, 0.0: bigint, 1.0: bigint]

freqItems

开始支持的版本 （1.4）
描述：为列查找频繁的出现的item，可能带有误报
参数：cols :要查找的列名 类型 list
例子：

In [22]: df.freqItems(["label","prediction"]).show()
+---------------+--------------------+
|label_freqItems|prediction_freqItems|
+---------------+--------------------+
|     [1.0, 0.0]|          [1.0, 0.0]|
+---------------+--------------------+

withColumn

开始支持的版本 （1.3）
描述：通过添加或替换与现有列有相同的名字的列，返回一个新的DataFrame
参数：colName：新列的名称 col：新列的colmun的表达式
例子：

In [40]: df3 = df1.withColumn("new_label",df1.label+1)
In [41]: df3.show()
+-----+----------+-----+---------+
|label|prediction|count|new_label|
+-----+----------+-----+---------+
| null|       1.0|   59|     null|
| null|      null|  100|     null|
|  0.0|       1.0|    2|      1.0|
|  0.0|      null|   43|      1.0|
|  0.0|       0.0|   41|      1.0|
|  1.0|       1.0|   57|      2.0|
|  1.0|      null|   57|      2.0|
| null|       0.0|   41|     null|
+-----+----------+-----+---------+

withColumnRenamed

开始支持的版本 （1.3）
描述：通过重命名一个已存在的colmun返回一个新的DataFrame
参数：existing:原列名，new:新列名
例子：

In [43]: df3.withColumnRenamed("new_label","label1").show()
+-----+----------+-----+------+
|label|prediction|count|label1|
+-----+----------+-----+------+
| null|       1.0|   59|  null|
| null|      null|  100|  null|
|  0.0|       1.0|    2|   1.0|
|  0.0|      null|   43|   1.0|
|  0.0|       0.0|   41|   1.0|
|  1.0|       1.0|   57|   2.0|
|  1.0|      null|   57|   2.0|
| null|       0.0|   41|  null|
+-----+----------+-----+------+

drop

开始支持的版本 （1.4）
描述：返回一个删除了指定列的新的DataFrame
参数：cols
例子：

>>> 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')]

>>> 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)]

>>> df.join(df2, 'name', 'inner').drop('age', 'height').collect()
[Row(name=u'Bob')]
"""

toDF

描述：根据指定的cols返回一个新的class：DataFrame
参数：cols 新的列名的list
例子：

lIn [49]: df.toDF("labels", "features", "rawPrediction", "probability", "prediction").dtypes
Out[49]:
[('labels', 'double'), ('features', 'vector'), ('rawPrediction', 'vector'), ('probability', 'vector'), ('prediction', 'double')]

In [50]: df.dtypes
Out[50]:
[('label', 'double'), ('features', 'vector'), ('rawPrediction', 'vector'), ('probability', 'vector'), ('prediction', 'double')]