管道中的函数编程与python熊猫数据

Question

我想知道哪一种是函数编程的最佳实践--编写一条函数管道来处理熊猫数据格式(或者任何其他可变的输入类型)作为函数的输入。

这里有两个想法，但希望有更好的东西存在:)

idea #1-没有函数式编程，而是节省内存

def foo(df, param):
    df['col'] = df['col'] + param

def pipeline(df):
    foo(df, 1)
    foo(df, 2)
    foo(df, 3)

idea #2-更多的函数式编程，但通过执行.copy()来浪费内存

def foo(df, param):
    df = df.copy()
    df['col'] = df['col'] + param
    return df

def pipeline(df):
    df1 = foo(df, 1)
    df2 = foo(df1, 2)
    df3 = foo(df2, 3)

Answer 1

如果您的数据是一维的(也就是说，它是一个项目列表)，那么您可以不使用多个管道一次完成所有操作。例如，我们将获得一个数据帧。

>>> table
     Name  Year of Birth      City
0    Mike           1970  New York
1   Chris           1981     Miami
2  Janine           1975   Seattle

我们要计算年龄，看看是否住在迈阿密。您可以应用两个管道，但是可以用一个lambda来完成：

>>> f = lambda s: pd.Series([2019 - s['Year of Birth'], s['City'] == 'Miami'])

然后应用它

>>> table[['Age', 'Lives in Miami']] = table.apply(f, axis=1)
>>> table
     Name  Year of Birth      City  Age  Lives in Miami
0    Mike           1970  New York   49           False
1   Chris           1981     Miami   38            True
2  Janine           1975   Seattle   44           False

所有的工作都是用f完成的。

另一个例子:假设你想检查谁超过45岁。这包含两个串行操作(前面的示例是2个paralel操作)：

1. 计算年龄
2. 检查年龄是否大于45岁

您可以使用2个管道，但同样可以通过应用一个lambda来完成这一切：

>>> table
     Name  Year of Birth      City   
0    Mike           1970  New York            
1   Chris           1981     Miami           
2  Janine           1975   Seattle      
>>> g = lambda s: pd.Series([2019 - s['Year of Birth'] > 45])              
>>> table['Older than 45'] = table.apply(g, axis=1)
>>> table
     Name  Year of Birth      City  Older than 45
0    Mike           1970  New York           True
1   Chris           1981     Miami          False
2  Janine           1975   Seattle          False

如果你喜欢不变性，那就做吧。

>>> table
     Name  Year of Birth      City
0    Mike           1970  New York
1   Chris           1981     Miami
2  Janine           1975   Seattle 
>>> pd.concat([table, table.apply(f, axis=1)], axis=1)
     Name  Year of Birth      City   0      1
0    Mike           1970  New York  49  False
1   Chris           1981     Miami  38   True
2  Janine           1975   Seattle  44  False

如果您不喜欢lambdas，那么定义

def f(s):
    return pd.Series([2019 - s['Year of Birth'], 
                      s['City'] == 'Miami'])

只有当您想应用只需要在单个单独行上工作的映射时，这一切才有效。此外，我没有提出任何关于速度，管道可能更快，但这是非常可读的。

(最终你会意识到你最好使用Haskell。)

Answer 2

您可以在dataframe上运行的链式函数调用。还可以看看熊猫中的DataFrame.pipe。如下所示，添加了几个非foo操作：

df = (df.pipe(foo,1)
      .pipe(foo,2)
      .pipe(foo,3)
      .drop(columns=['drop','these'])
      .assign(NEW_COL=lambda x: x['OLD_COL'] / 10))

df将是在使用pipe时传递给foo的第一个参数。