E-num/在pyspark中获取假人

我想在PYSPARK中创建一个函数，用于获取数据帧和参数列表（代码/分类特征），并返回数据帧和其他虚拟列，如列表中的特征类别 DF前后的PFA：

python中的代码如下所示：

enum = ['column1','column2']

for e in enum:
    print e
    temp = pd.get_dummies(data[e],drop_first=True,prefix=e)
    data = pd.concat([data,temp], axis=1)
    data.drop(e,axis=1,inplace=True)

data.to_csv('enum_data.csv')

---

第一步是从CSV文件生成一个

数据帧

看；第一个答案给出了一个逐行的例子

然后可以添加列。假设您有一个名为
df
的
DataFrame
对象，列为：[
ID
，
TYPE
，
code
]

剩余的变量可以用
DataFrame.withColumn（）和
pyspark.sql.functions固定。当
时：

from pyspark.sql.functions import when

df_with_extra_columns = df.withColumn("e_TYPE_A", when(df.TYPE == "A", 1).otherwise(0).withColumn("e_TYPE_B", when(df.TYPE == "B", 1).otherwise(0)

（这添加了前两列。你明白了。）
首先，你需要收集
类型
和
代码
的不同值。然后，使用
withColumn
选择addcolumn和每个值的名称，或者使用select from每个列。
下面是使用select语句的示例代码：-

import pyspark.sql.functions as F
df = sqlContext.createDataFrame([
    (1, "A", "X1"),
    (2, "B", "X2"),
    (3, "B", "X3"),
    (1, "B", "X3"),
    (2, "C", "X2"),
    (3, "C", "X2"),
    (1, "C", "X1"),
    (1, "B", "X1"),
], ["ID", "TYPE", "CODE"])

types = df.select("TYPE").distinct().rdd.flatMap(lambda x: x).collect()
codes = df.select("CODE").distinct().rdd.flatMap(lambda x: x).collect()
types_expr = [F.when(F.col("TYPE") == ty, 1).otherwise(0).alias("e_TYPE_" + ty) for ty in types]
codes_expr = [F.when(F.col("CODE") == code, 1).otherwise(0).alias("e_CODE_" + code) for code in codes]
df = df.select("ID", "TYPE", "CODE", *types_expr+codes_expr)
df.show()

输出

+---+----+----+--------+--------+--------+---------+---------+---------+
| ID|TYPE|CODE|e_TYPE_A|e_TYPE_B|e_TYPE_C|e_CODE_X1|e_CODE_X2|e_CODE_X3|
+---+----+----+--------+--------+--------+---------+---------+---------+
|  1|   A|  X1|       1|       0|       0|        1|        0|        0|
|  2|   B|  X2|       0|       1|       0|        0|        1|        0|
|  3|   B|  X3|       0|       1|       0|        0|        0|        1|
|  1|   B|  X3|       0|       1|       0|        0|        0|        1|
|  2|   C|  X2|       0|       0|       1|        0|        1|        0|
|  3|   C|  X2|       0|       0|       1|        0|        1|        0|
|  1|   C|  X1|       0|       0|       1|        1|        0|        0|
|  1|   B|  X1|       0|       1|       0|        1|        0|        0|
+---+----+----+--------+--------+--------+---------+---------+---------+

Freek Wiemkeijer和Rakesh Kumar提供的解决方案是完全足够的，但是，由于我对它进行了编码，我认为发布这个通用解决方案是值得的，因为它不需要对列名进行硬编码

pivot_cols = ['TYPE','CODE']
keys = ['ID','TYPE','CODE']

before = sc.parallelize([(1,'A','X1'),
                         (2,'B','X2'),
                         (3,'B','X3'),
                         (1,'B','X3'),
                         (2,'C','X2'),
                         (3,'C','X2'),
                         (1,'C','X1'),
                         (1,'B','X1')]).toDF(['ID','TYPE','CODE'])                         

#Helper function to recursively join a list of dataframes
#Can be simplified if you only need two columns
def join_all(dfs,keys):
    if len(dfs) > 1:
        return dfs[0].join(join_all(dfs[1:],keys), on = keys, how = 'inner')
    else:
        return dfs[0]

dfs = []
combined = []
for pivot_col in pivot_cols:
    pivotDF = before.groupBy(keys).pivot(pivot_col).count()
    new_names = pivotDF.columns[:len(keys)] +  ["e_{0}_{1}".format(pivot_col, c) for c in pivotDF.columns[len(keys):]]        
    df = pivotDF.toDF(*new_names).fillna(0)    
    combined.append(df)

join_all(combined,keys).show()

这将作为输出提供：

+---+----+----+--------+--------+--------+---------+---------+---------+
| ID|TYPE|CODE|e_TYPE_A|e_TYPE_B|e_TYPE_C|e_CODE_X1|e_CODE_X2|e_CODE_X3|
+---+----+----+--------+--------+--------+---------+---------+---------+
|  1|   A|  X1|       1|       0|       0|        1|        0|        0|
|  2|   C|  X2|       0|       0|       1|        0|        1|        0|
|  3|   B|  X3|       0|       1|       0|        0|        0|        1|
|  2|   B|  X2|       0|       1|       0|        0|        1|        0|
|  3|   C|  X2|       0|       0|       1|        0|        1|        0|
|  1|   B|  X3|       0|       1|       0|        0|        0|        1|
|  1|   B|  X1|       0|       1|       0|        1|        0|        0|
|  1|   C|  X1|       0|       0|       1|        1|        0|        0|
+---+----+----+--------+--------+--------+---------+---------+---------+

我一直在寻找相同的解决方案，但它是scala，也许这会帮助某些人：

val list = df.select("category").distinct().rdd.map(r => r(0)).collect()
val oneHotDf = list.foldLeft(df)((df, category) => finalDf.withColumn("category_" + category, when(col("category") === category, 1).otherwise(0)))

如果您想获得PySpark版本的pandas“pd.get_dummies”函数，可以使用以下函数：

import itertools

def spark_get_dummies(df):
    
    categories = []
    for i, values in enumerate(df.columns):
        categories.append(df.select(values).distinct().rdd.flatMap(lambda x: x).collect())
        
    expressions = []
    for i, values in enumerate(df.columns):
        expressions.append([F.when(F.col(values) == i, 1).otherwise(0).alias(str(values) + "_" + str(i)) for i in categories[i]])
    
    expressions_flat = list(itertools.chain.from_iterable(expressions))
    
    df_final = df.select(*expressions_flat)
    
    return df_final

可再现的示例为：

df = sqlContext.createDataFrame([
    ("A", "X1"),
    ("B", "X2"),
    ("B", "X3"),
    ("B", "X3"),
    ("C", "X2"),
    ("C", "X2"),
    ("C", "X1"),
    ("B", "X1"),
], ["TYPE", "CODE"])

dummies_df = spark_get_dummies(df)
dummies_df.show()

您将获得：

（问题是关于python的。这篇文章似乎并没有为这个问题提供答案）。我认为如果有人分享知识，那么这总是一个双赢的结果，而你唯一能做的就是从Ysegal的答案中获益。我不喜欢别人对他们的工作感到气馁，因为他们认为他们必须严格遵守一些规则集（无论上下文或情况）。我试图在一个大数据帧上运行此代码，这需要很长时间。我是spark的新手。你认为这段代码不适合大数据集吗？如果是的话，有没有提高性能的方法。你有没有尝试过Kumars的解决方案。如果你有很多列，这个解决方案不会特别快。我需要能够在没有硬编码的情况下对很多列执行此操作这就是我使用你的解决方案的原因，有没有办法在没有硬编码的情况下运行Kumars解决方案？当我尝试运行df.show（）时，它不会显示所有的虚拟列