主页 / user-15452898

mabramov's questions

Martin Hope
mabanalyst
Asked: 2025-01-19 04:45:15 +0800 CST
  • 5

目前，我正在对包含借款人如何偿还贷款的信息的数据库进行计算。

从技术角度来看，我正在使用 PySpark，刚刚面临如何使用高级过滤操作的问题。

我的数据框如下所示：

ID     ContractDate LoanSum  ClosingDate Status Bank
ID3    2024-06-10   20                   Active A
ID3    2024-06-11   30                   Active A
ID3    2024-06-12   50                   Active A
ID3    2024-06-12   15                   Active B
ID3    2024-06-12   5        2024-06-18  Closed A
ID3    2024-06-13   40       2024-06-20  Closed A
ID3    2024-06-22   50                   Active A
ID4    2024-07-11   20                   Active A
ID4    2024-07-12   30                   Active B
ID4    2024-07-13   50                   Active B
ID4    2024-07-11   5        2024-08-20  Closed A

我的目标是通过“贷款金额”字段计算借款人的总和，这些借款人拥有同一家银行在首笔贷款发放之日起 3 天内发放的 3 笔或更多有效贷款。

在我的例子中，ID3 的总和为 20 + 30 + 50 = 100

我目前所做的：

from pyspark.sql import functions as f
from pyspark.sql import Window

df = spark.createDataFrame(data).toDF('ID','ContractDate','LoanSum','ClosingDate', 'Status', 'Bank')
df.show()

cols = df.columns
w = Window.partitionBy('ID').orderBy('ContractDate')

df.withColumn('PreviousContractDate', f.lag('ContractDate').over(w)) \
  .withColumn('Target', f.expr('datediff(ContractDate, PreviousContractDate) >= 0 & datediff(ContractDate, PreviousContractDate) <= 3')) \
  .withColumn('Target', f.col('Target') | f.lead('Target').over(w)) \
  .filter('Target == True')

此代码仅有助于根据 ContractDate 获取向一名借款人发放的贷款。

我如何添加更多条件？

pyspark
Martin Hope
mabanalyst
Asked: 2024-08-23 03:04:44 +0800 CST
  • 6

目前，我正在处理一个大型数据框并面临一个问题。

我想返回表中每个值重复的次数（计数）。

例如：数字 10 重复了两次，所以我想得到数字 2，依此类推...

我的代码是：

from pyspark.sql.types import StructType, StructField, StringType, IntegerType, DateType

right_table_23 = [
    ("ID1", 2),
    ("ID2", 3),
    ("ID3", 5),
    ("ID4", 6),
    ("ID6", 10),
    ("ID8", 15),
    ("ID9", 10),
    ("ID10", 5),
    ("ID2", 5),
    ("ID3", 8),
    ("ID4", 3),
    ("ID2", 2),
    ("ID3", 4),
    ("ID4", 3)
]

上表的架构如下：

schema = StructType([
    StructField("ID", StringType(), True),
    StructField("Count", IntegerType(), True)
    ])

接下来我使用以下代码创建表格：

df_right_table_23 = spark.createDataFrame(right_table_23, schema)

为了计算重复次数，我使用以下代码：

#It can be implemented in order to find repetitions for a number 2
df_right_table_23.select().where(df_right_table_23.count == 2).count()

但是如果数字范围包括从 2 到 100 的数字，则重写上述代码会很困难且耗时。

是否有可能以某种方式使重复计数的过程自动化？

python
Martin Hope
mabanalyst
Asked: 2024-01-21 06:38:10 +0800 CST
  • 5

目前，我正在对包含交易信息的数据库执行计算。这是一个大数据集，消耗大量资源，并且刚刚面临如何使用优化我当前的解决方案的问题。

我的初始数据框如下所示：

Name    ID     ContractDate LoanSum Status
A       ID1    2022-10-10   10      Closed 
A       ID1    2022-10-15   13      Active
A       ID1    2022-10-30   20      Active
B       ID2    2022-11-05   30      Active
C       ID3    2022-12-10   40      Closed
C       ID3    2022-12-12   43      Active
C       ID3    2022-12-19   46      Active
D       ID4    2022-12-10   10      Closed
D       ID4    2022-12-12   30      Active

我必须创建一个数据框，其中包含发放给特定借款人（按 ID 分组）的所有贷款，其中两笔贷款（分配给一个唯一 ID）之间的天数小于 15，并且发放给一个特定借款人的贷款金额之间的差异更小或等于 3。

我的解决方案：

from pyspark.sql import functions as f
from pyspark.sql import Window

df = spark.createDataFrame(data).toDF('Name','ID','ContractDate','LoanSum','Status')
df.show()

cols = df.columns
w = Window.partitionBy('ID').orderBy('ContractDate')

new_df = df.withColumn('PreviousContractDate', f.lag('ContractDate').over(w)) \
  .withColumn('PreviousLoanSum', f.lag('LoanSum').over(w)) \
  .withColumn('Target', f.expr('datediff(ContractDate, PreviousContractDate) < 15 and LoanSum - PreviousLoanSum <= 3')) \
  .withColumn('Target', f.col('Target') | f.lead('Target').over(w)) \
  .filter('Target == True') \
  .select(cols[0], *cols[1:])

+----+---+------------+-------+------+
|Name| ID|ContractDate|LoanSum|Status|
+----+---+------------+-------+------+
|   A|ID1|  2022-10-10|     10|Closed|
|   A|ID1|  2022-10-15|     13|Active|
|   C|ID3|  2022-12-10|     40|Closed|
|   C|ID3|  2022-12-12|     43|Active|
|   C|ID3|  2022-12-19|     46|Active|
+----+---+------------+-------+------+

如您所见，我的结果存储在单独的表中。我的下一个目标是从初始数据帧“df”中删除数据帧“new_df”，以便处理相关行。

如果我使用这个明显的解决方案，系统运行速度非常慢，特别是当我必须在每一步中一一减去数据帧时：

df_sub = df.subtract(new_df)

我的问题：是否有可能（如果是，那么如何）不创建新的数据帧，而是创建第一个数据帧 df 内的数据帧 new_df 中包含的单独行？也许通过创建一个新列以特殊方式标记行，以便过滤稍后进一步分析所需的行？

先感谢您！

python
Martin Hope
mabanalyst
Asked: 2024-01-16 02:55:44 +0800 CST
  • 6

我目前正在尝试练习一些数据操作程序，并面临着如何根据特殊条件创建子集的问题。

我们假设数据框如下所示：

Name    ID     ContractDate LoanSum DurationOfDelay
A       ID1    2023-01-01   10      10 
A       ID1    2023-01-03   15      15
A       ID1    2022-12-29   20      0
A       ID1    2022-12-28   40      0
B       ID2    2023-01-05   15      19
B       ID2    2023-01-10   30      0
B       ID2    2023-01-07   35      25
B       ID2    2023-01-06   35      0

我的目标是为每个唯一 ID（或名称）显示首先发放的贷款的索引号，且 DurationOfDelay > 0

预期结果：

Name    ID     IndexNum
A       ID1    3 
B       ID2    1

说明：对于 ID1，发放了四笔贷款：2022-12-28、2022-12-29、2023-01-01 和 2023-01-03。我们可以在 2023-01-01 首先识别出 DurationOfDelay > 0 的存在，这是向借款人发放的第三笔贷款。

ID2 还发放了四笔贷款：2023-01-05、2023-01-06、2023-01-07 和 2023-01-10。我们可以在 2023-01-05 首先识别出 DurationOfDelay > 0 的存在，这是向借款人发放的第一笔贷款。

到目前为止我所做的：

window_spec_subset = Window.partitionBy('ID').orderBy('ContractDate')
subset = df.filter(F.col('DurationOfDelay') > 0) \
                .withColumn('row_num', F.row_number().over(window_spec_subset)) \
                .filter(F.col('row_num') == 1) \
                .drop('row_num')
subset.show()

+----+---+------------+-------+---------------+
|Name| ID|ContractDate|LoanSum|DurationOfDelay|
+----+---+------------+-------+---------------+
|   A|ID1|  2023-01-01|     10|             10|
|   B|ID2|  2023-01-05|     15|             19|
+----+---+------------+-------+---------------+

这段代码允许我以这样的方式对数据进行分组：对于每个借款人，仅返回最先发放且 DurationOfDelay > 0 的贷款。

但我堆叠起来显示首先发放的贷款的索引号，而 DurationOfDelay > 0。

您愿意帮助我取得这些成果吗？非常感谢任何形式的帮助！

python
Martin Hope
mabramov
Asked: 2024-01-14 04:37:27 +0800 CST
  • 5

我目前正在做一些数据操作程序，并遇到了如何根据特殊条件创建子集的问题。

我的例子（数据框）是这样的：

Name    ID     ContractDate LoanSum DurationOfDelay
A       ID1    2023-01-01   10      0 
A       ID1    2023-01-03   15      0
A       ID1    2022-12-29   20      35
A       ID1    2022-12-28   40      91

B       ID2    2023-01-05   15      0
B       ID2    2023-01-10   30      100
B       ID2    2023-01-07   35      40
B       ID2    2023-01-06   35      0

C       ID3    2023-01-09   20      0
C       ID3    2023-01-07   30      0
C       ID3    2023-01-11   35      0

我的目标是创建两个不同的子集（两个新的数据帧）：

  1. 创建一个表，其中包含最后发放的贷款

预期结果：

Name    ID     ContractDate LoanSum DurationOfDelay
A       ID1    2023-01-03   15      0
B       ID2    2023-01-10   30      100
C       ID3    2023-01-11   35      0
  1. 以这样的方式对数据进行分组，即对于每个借款人，仅返回最先发放且 DurationOfDelay > 0 的贷款

预期结果：

Name    ID     ContractDate LoanSum DurationOfDelay
A       ID1    2022-12-28   40      91
B       ID2    2023-01-07   35      40

您愿意帮助我取得这些成果吗？非常感谢任何形式的帮助！

python