研究下“花呗”到底该不该用？

编程语言 2019-04-14 19:10:52 阅读次数: 0

如何用数据挖掘“花呗”到底该不该用？

在这里插入图片描述

基于蒙特卡洛原理：

→ 如果当月全部花费全部由花呗支付，当当月花呗欠款大于当月可支出收入时，就要“吃土了”

→ 预设计算120个月(十年)，假如十年都没能够吃上土，那就代表愿望成真

  • “收入多少？” —— 每月净收入模型构建
  • “花费多少？” —— 每月开支模型构建
  • “是否吃土？” —— 使用花呗还款情况模拟
  • “用了花呗会怎么样？” —— 用花呗的不同情况下，看看偿还额度的变化
import numpy as np  
import pandas as pd 
import matplotlib.pyplot as plt
import matplotlib  as mpl
mpl.rcParams['font.sans-serif'] = ['simHei']
mpl.rcParams['axes.unicode_minus'] = False
import matplotlib.style as psl
psl.use('seaborn-colorblind')
% matplotlib inline
# 设置一个图标风格
# 魔法函数

1、“收入多少？” —— 每月净收入模型构建

  • 净收入 = 月薪 - 五险一金 + 奖金 - 个人所得税
  • 假设换了一份月薪1W的工作，且公司每月会根据绩效给予1500元左右的奖金

上海市五险一金缴纳系数

在这里插入图片描述
上海市五险一金及税后工资计算器：

个税政策

在这里插入图片描述

# 构建税费计算函数

def tax(salary_sum):
    if salary_sum <= 3500:
        # 月薪低于3500元；
        return 0
    elif salary_sum <= (3500 + 1500):
        # 月薪在3500-4500元之间；
        return (salary_sum - 3500) * 0.03
    elif salary_sum <= (3500 + 1500 + 3000):
        # 月薪在4500-8000元之间；
        return 1500 * 0.03 + (salary_sum - 1500 - 3500) * 0.1
    elif salary_sum <= (3500 + 1500 + 3000 + 4500):
        # 月薪在8000-12500元之间；
        return 1500 * 0.03 + 3000 * 0.1 + (salary_sum - 3500 - 1500 - 3000) * 0.2
    elif salary_sum <= (3500 + 1500 + 3000 + 4500 + 26000):
        # 月薪在12500-38500元之间；
        return 1500 * 0.03 + 3000 * 0.1 + 4500 * 0.2 + (salary_sum - 3500 - 1500 - 3000 - 4500) * 0.25
    elif salary_sum <= (3500 + 1500 + 3000 + 4500 + 26000 + 20000):
        # 月薪在38500-58500元之间；
        return 1500 * 0.03 + 3000 * 0.1 + 4500 * 0.2 + 26000 * 0.25 + (salary_sum - 3500 - 1500 - 3000 - 4500 - 26000) * 0.3
    elif salary_sum <= (3500 + 1500 + 3000 + 4500 + 26000 + 20000 + 25000):
        # 月薪在58500-83500元之间；
        return 1500 * 0.03 + 3000 * 0.1 + 4500 * 0.2 + 26000 * 0.25 + 20000 * 0.3 + (salary_sum - 3500 - 1500 - 3000 - 4500 - 26000 - 20000) * 0.35
    else:
        # 月薪在83500元以上；
        return 1500 * 0.03 + 3000 * 0.1 + 4500 * 0.2 + 26000 * 0.25 + 20000 * 0.3 + 25000 * 0.35 + (salary_sum - 3500 - 1500 - 3000 - 4500 - 26000 - 20000 - 25000) * 0.45

test = 45000
print('函数构建完成，当月薪为%.1f元时，需要缴税%.2f元' % (test,tax(test)))

函数构建完成，当月薪为45000.0元时，需要缴税9695.00元

# 构建五险一金函数

def insurance(salary):
    if salary <= 21396:
        return salary * 0.175
    else:
        return 3744.58

test = 15000
print('函数构建完成，当月薪为%.1f元时，需要缴五险一金%.2f元' % (test,insurance(test)))

函数构建完成，当月薪为15000.0元时，需要缴五险一金2625.00元

# 构建奖金随机函数

def bonus(b_avg):
    # 预设10年的奖金，生成120个随机值
    return pd.Series(np.random.normal(loc = b_avg,scale = 200,size = 120))

print('函数构建完成，当奖金均值为1500时，随机数组为：')
print(bonus(1500)[:10])

plt.title('奖金随机函数 - 数据分布直方图')
plt.hist(bonus(1500),bins = 30)
plt.grid()
# 绘制直方图

函数构建完成，当奖金均值为1500时，随机数组为：
0    1367.490124
1    1707.555061
2    1891.970924
3    1500.842463
4    1578.909590
5    1370.132893
6    1702.545936
7    1686.156750
8    1591.627115
9    1742.975270
dtype: float64

在这里插入图片描述

# 构建每月净收入函数

def final_income(s,b_avg):
    df_i = pd.DataFrame({
            '月薪':[s for i in range(120)],                  # 月薪基数
            '五险一金':[insurance(s) for i in range(120)],   # 计算五险一金
            '奖金':bonus(b_avg)                              # 计算奖金
        })
    df_i['计税部分'] = df_i['月薪'] + df_i['奖金']
    df_i['个人所得税'] = df_i['计税部分'].apply(lambda x : tax(x))  # 计算个人所得税
    df_i['月净收入'] = df_i['月薪'] - df_i['五险一金'] + df_i['奖金'] - df_i['个人所得税']
    return df_i
    # return  → 返回一个dataframe
    
result = final_income(10000,1500)
# 测试结果 → 当月收入1万，平均奖金1500元时的月净收入情况

result['月净收入'].iloc[:12].plot(kind='bar',figsize = (12,4),color='Green')
plt.title('月净收入情况 - 前12月')
plt.grid()

result.head()
# .head()查看头5条数据
五险一金 奖金 月薪 计税部分 个人所得税 月净收入
0 1750.0 1588.668883 10000 11588.668883 1062.733777 8775.935107
1 1750.0 1539.295856 10000 11539.295856 1052.859171 8736.436685
2 1750.0 1341.057045 10000 11341.057045 1013.211409 8577.845636
3 1750.0 1295.503319 10000 11295.503319 1004.100664 8541.402655
4 1750.0 1593.091777 10000 11593.091777 1063.618355 8779.473421

在这里插入图片描述

2、“花费多少？” —— 每月开支模型构建

  • 基本生活支出 → 以她奢侈的生活，一天100不在话下，但由于是基本支出，变化也不会太大。我设定以3000元和3500元为限，均匀分布
  • 购物支出 → 暗恋对象有句名言，“工资一分二，购物拿一半。”所以，模型设定为以5000元为均值，500元为标准差的正态分布
  • 娱乐支出 → 暗恋对象闺蜜众多，每周一次的girl’s night是不能少的，一次至少花个100，多则300不过分吧。所以，模型设定以400元和1200元为限，均匀分布
  • 学习支出 → 爱学习应该是暗恋对象少有的优点，某在线平台课程价格大概在100元到500元不等。所以，这个也可以设定个均匀分布的模型
  • 其他支出 → 每个月总会有些意外什么的，比如出门掉了个钱包等等。所以，为了计算尽可能接近真实，我设定500元为均值，40元为标准差的正态分布模型

总支出=基本生活+购物+娱乐+学习+其他

# 基本生活支出

general_expense = pd.Series(np.random.randint(3000,3501,size=120))
plt.title('基本生活支出')
plt.hist(general_expense,bins = 30)
plt.grid()
# 绘制直方图

在这里插入图片描述

扫描二维码关注公众号，回复： 5887810 查看本文章 
# 购物支出

shopping = pd.Series(np.random.normal(loc=5000,scale=500,size=120))
plt.title('购物支出')
plt.hist(shopping,bins = 30)
plt.grid()
# 绘制直方图

在这里插入图片描述

# 娱乐支出

happy = pd.Series(np.random.randint(400,1200,size=120))
plt.title('娱乐支出')
plt.hist(happy,bins = 30)
plt.grid()
# 绘制直方图

在这里插入图片描述

# 学习支出

study = pd.Series(np.random.randint(100,500,size=120))
plt.title('学习支出')
plt.hist(study,bins = 30)
plt.grid()
# 绘制直方图

在这里插入图片描述

# 其他支出

other = pd.Series(np.random.normal(loc=500,scale=40,size=120))
plt.title('其他支出')
plt.hist(other,bins = 30)
plt.grid()
# 绘制直方图

在这里插入图片描述

# 构建每月开支函数

def final_expense():
    df_i = pd.DataFrame({
            '基本生活支出':np.random.randint(3000,3501,size=120),
            '购物支出':np.random.normal(loc=5000,scale=500,size=120),
            '娱乐支出':np.random.randint(400,1200,size=120),
            '学习支出':np.random.randint(100,500,size=120),
            '其他支出':np.random.normal(loc=500,scale=40,size=120)
        })
    df_i['月总支出'] = df_i['基本生活支出'] + df_i['购物支出'] + df_i['娱乐支出'] + df_i['学习支出'] + df_i['其他支出']
    return df_i
    # return  → 返回一个dataframe
    
result = final_expense()
# 测试结果 → 随机构建每月支出情况

result[['基本生活支出','购物支出','娱乐支出','学习支出','其他支出']].iloc[:12].plot(kind='bar',
                                                              figsize = (12,4),
                                                              stacked = True,
                                                              colormap = 'Reds_r')
plt.title('月总支出情况 - 前12月')
plt.grid()

result.head()
其他支出 基本生活支出 娱乐支出 学习支出 购物支出 月总支出
0 497.302429 3440 689 317 6042.073209 10985.375638
1 492.882529 3297 1049 382 4306.480868 9527.363398
2 538.277618 3208 1062 235 4411.161792 9454.439410
3 564.221604 3026 504 159 5129.968614 9383.190218
4 460.558753 3431 1121 174 5284.007878 10470.566631

在这里插入图片描述

3、“是否吃土？” —— 使用花呗还款情况模拟

整理几个约束条件：

  • 每月先还欠款，再消费。
  • 所有的支出除还款外，都可以使用花呗透支。
  • 当这月的收入小于等于需要还款的金额，就代表你要吃土了
  • 花呗信用总额度为1.5万

所以如何算破（吃）产（土）呢？

当月还需借贷花呗金额 = 月初余额 + 月收入 - 月支出 - 本月需还花呗 > 15000 时

# 创建120个月每月的①月收入，②月支出，③月初余额，④本月需还花呗，这里用0元来填充

income = final_income(10000,1500)['月净收入'].tolist()
expense = final_expense()['月总支出'].tolist()
saving = [0 for i in range(120)]
debt = [0 for i in range(120)]

print('前6个月的月收入，月支出，月初余额（未计算），本月需还花呗（未计算） 数据分别为：\n')
print(income[:6])
print(expense[:6])
print(saving[:6])
print(debt[:6])

前6个月的月收入，月支出，月初余额（未计算），本月需还花呗（未计算） 数据分别为：

[8671.354407484552, 8869.05979519114, 8604.519596925978, 9075.881643538856, 8605.88945231119, 8696.638150398318]
[10678.765703440291, 10348.918097588125, 10200.358235336866, 8987.087371851503, 9377.37124634694, 9414.932245897835]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]

第一回合：不使用分期功能

# 第二个月推导

if income[0] >= expense[0]:
    '''
    第一个月收入大于等于支出时：
    第二个月月初余额 = 第一个月收入 - 第一个月支出
    第二个月需还花呗 = 0
    '''
    saving[1] = income[0] - expense[0]
    debt[1] = 0
else:
    '''
    第一个月收入小于支出时：
    第二个月月初余额 = 0
    第二个月需还花呗 = 第一个月支出 - 第一个月收入
    '''
    saving[1] = 0
    debt[1] = expense[0] - income[0]

print(income[:2])
print(expense[:2])
print(saving[:2])
print(debt[:2])

[8671.354407484552, 8869.05979519114]
[10678.765703440291, 10348.918097588125]
[0, 0]
[0, 2007.4112959557388]

# 构建函数模拟

income = final_income(10000,1500)['月净收入'].tolist()
expense = final_expense()['月总支出'].tolist()
saving = [0 for i in range(120)]
debt = [0 for i in range(120)]

def case_a():
    month = []
    data = []
    # 创建两个空列表，用于存放月份和每月数据
    
    for i in range(120):
        money = saving[i] + income[i] - debt[i] - expense[i]  # 当月还需借贷花呗金额 = 月初余额 + 月收入 - 月支出 - 本月需还花呗
        #print(money)
        if -money > 15000:
            # 当月还需借贷花呗金额大于15000元时 → 破（吃）产（土）
            print('第%i个月花呗也救不了我了，要破（吃）产（土）了！\n-------' % (i+1))
            break
        else:
            # 当月还需借贷花呗金额小于等于15000元时 → 继续浪
            if money >= 0:
                saving[i+1] = saving[i] + income[i] - expense[i] - debt[i]
                debt[i+1] = 0
            else:
                saving[i+1] = 0
                debt[i+1] = expense[i] + debt[i] - income[i] - saving[i]
        month.append(i+1)
        data.append([income[i],expense[i],debt[i],saving[i+1],debt[i+1]])
    # 创建循环，模拟每月花呗使用情况
    
    result_a = pd.DataFrame(data,columns=['月收入','月支出','本月需还花呗','本月余钱','欠债'],index = month)
    result_a.index.name = '月份'
    # 将数据存为Dataframe
    
    return result_a

case_a()

第13个月花呗也救不了我了，要破（吃）产（土）了！
-------
月收入 月支出 本月需还花呗 本月余钱 欠债
月份
1 8681.780967 9877.634413 0.000000 0 1195.853445
2 8738.951195 9071.504566 1195.853445 0 1528.406817
3 9065.070601 11252.336547 1528.406817 0 3715.672763
4 8360.093435 11018.560639 3715.672763 0 6374.139966
5 8809.520601 10355.257101 6374.139966 0 7919.876467
6 8868.918668 8705.602349 7919.876467 0 7756.560148
7 8491.283500 10039.671667 7756.560148 0 9304.948315
8 8728.472345 9619.446057 9304.948315 0 10195.922026
9 8428.517242 9300.045999 10195.922026 0 11067.450783
10 8734.875596 9913.616808 11067.450783 0 12246.191994
11 8885.632756 9104.904071 12246.191994 0 12465.463309
12 8739.980131 10287.163476 12465.463309 0 14012.646655 
# 第一回合：不使用分期情况下，进行1万次模拟，查看破产月份

month_case_a = []    
for i in range(10000): 
    print('正在进行第%i次模拟' % (i+1))
    income = final_income(10000,1500)['月净收入'].tolist()
    expense = final_expense()['月总支出'].tolist()
    saving = [0 for i in range(120)]
    debt = [0 for i in range(120)]
    result_a = case_a().index.max()
    month_case_a.append(result_a)

result_a = pd.Series(month_case_a)

在这里插入图片描述

# 基于10000次模拟的破（吃）产（土）月份，制作直方图

plt.figure(figsize = (12,4))
result_a.hist(bins=15)
plt.title('第一回合：不可分期 - 模拟结果')

在这里插入图片描述

第二回合：允许分期

分期相当于把当月需要还的款项分摊到之后数个月，当月的负担减小了，但代价是支付一定的利息。此时我快速翻出了花呗的利率表：

在这里插入图片描述
可以看到 … 现在余额宝年化3.5%，而花呗分期基本都是10%左右！！！！

# 构建函数模拟 - 分期三月

income = final_income(10000,1500)['月净收入'].tolist()
expense = final_expense()['月总支出'].tolist()
saving = [0 for i in range(120)]
debt = [0 for i in range(120)]

def case_b():
    month = []
    data = []
    # 创建两个空列表，用于存放月份和每月数据
    
    for i in range(120):
        money = saving[i] + income[i] - debt[i] - expense[i]  # 当月还需借贷花呗金额 = 月初余额 + 月收入 - 月支出 - 本月需还花呗
        #print(money)
        if -money > 15000:
            # 当月还需借贷花呗金额大于15000元时 → 破（吃）产（土）
            print('第%i个月花呗也救不了我了，要破（吃）产（土）了！\n-------' % (i+1))
            break
        else:
            # 当月还需借贷花呗金额小于等于15000元时 → 继续浪
            if money >= 0:
                saving[i+1] = saving[i] + income[i] - expense[i] - debt[i]
                debt[i+1] = 0
            else:
                money_per = (abs(money) * (1+0.025))/3    # 分期三月
                saving[i+1] = 0
                debt[i+1] = debt[i+1] + money_per
                debt[i+2] = debt[i+2] + money_per
                debt[i+3] = debt[i+3] + money_per
        month.append(i+1)
        data.append([income[i],expense[i],debt[i],saving[i+1],debt[i+1]])
    # 创建循环，模拟每月花呗使用情况
    
    result_b = pd.DataFrame(data,columns=['月收入','月支出','本月需还花呗','本月余钱','欠债'],index = month)
    result_b.index.name = '月份'
    # 将数据存为Dataframe
    
    return result_b

case_b()

在这里插入图片描述

# 构建函数模拟 - 分期六月

income = final_income(10000,1500)['月净收入'].tolist()
expense = final_expense()['月总支出'].tolist()
saving = [0 for i in range(120)]
debt = [0 for i in range(120)]

def case_c():
    month = []
    data = []
    # 创建两个空列表，用于存放月份和每月数据
    
    for i in range(120):
        money = saving[i] + income[i] - debt[i] - expense[i]  # 当月还需借贷花呗金额 = 月初余额 + 月收入 - 月支出 - 本月需还花呗
        #print(money)
        if -money > 15000:
            # 当月还需借贷花呗金额大于15000元时 → 破（吃）产（土）
            print('第%i个月花呗也救不了我了，要破（吃）产（土）了！\n-------' % (i+1))
            break
        else:
            # 当月还需借贷花呗金额小于等于15000元时 → 继续浪
            if money >= 0:
                saving[i+1] = saving[i] + income[i] - expense[i] - debt[i]
                debt[i+1] = 0
            else:
                money_per = (abs(money) * (1+0.045))/6    # 分期六月
                saving[i+1] = 0
                debt[i+1] = debt[i+1] + money_per
                debt[i+2] = debt[i+2] + money_per
                debt[i+3] = debt[i+3] + money_per
                debt[i+4] = debt[i+4] + money_per
                debt[i+5] = debt[i+5] + money_per
                debt[i+6] = debt[i+6] + money_per
        month.append(i+1)
        data.append([income[i],expense[i],debt[i],saving[i+1],debt[i+1]])
    # 创建循环，模拟每月花呗使用情况
    
    result_c = pd.DataFrame(data,columns=['月收入','月支出','本月需还花呗','本月余钱','欠债'],index = month)
    result_c.index.name = '月份'
    # 将数据存为Dataframe
    
    return result_c

case_c()

在这里插入图片描述

# 构建函数模拟 - 分期九月

income = final_income(10000,1500)['月净收入'].tolist()
expense = final_expense()['月总支出'].tolist()
saving = [0 for i in range(120)]
debt = [0 for i in range(120)]

def case_d():
    month = []
    data = []
    # 创建两个空列表，用于存放月份和每月数据
    
    for i in range(120):
        money = saving[i] + income[i] - debt[i] - expense[i]  # 当月还需借贷花呗金额 = 月初余额 + 月收入 - 月支出 - 本月需还花呗
        #print(money)
        if -money > 15000:
            # 当月还需借贷花呗金额大于15000元时 → 破（吃）产（土）
            print('第%i个月花呗也救不了我了，要破（吃）产（土）了！\n-------' % (i+1))
            break
        else:
            # 当月还需借贷花呗金额小于等于15000元时 → 继续浪
            if money >= 0:
                saving[i+1] = saving[i] + income[i] - expense[i] - debt[i]
                debt[i+1] = 0
            else:
                money_per = (abs(money) * (1+0.065))/9    # 分期九月
                saving[i+1] = 0
                debt[i+1] = debt[i+1] + money_per
                debt[i+2] = debt[i+2] + money_per
                debt[i+3] = debt[i+3] + money_per
                debt[i+4] = debt[i+4] + money_per
                debt[i+5] = debt[i+5] + money_per
                debt[i+6] = debt[i+6] + money_per
                debt[i+7] = debt[i+7] + money_per
                debt[i+8] = debt[i+8] + money_per
                debt[i+9] = debt[i+9] + money_per
        month.append(i+1)
        data.append([income[i],expense[i],debt[i],saving[i+1],debt[i+1]])
    # 创建循环，模拟每月花呗使用情况
    
    result_d = pd.DataFrame(data,columns=['月收入','月支出','本月需还花呗','本月余钱','欠债'],index = month)
    result_d.index.name = '月份'
    # 将数据存为Dataframe
    
    return result_d

case_d()

在这里插入图片描述

# 构建函数模拟 - 分期十二月

income = final_income(10000,1500)['月净收入'].tolist()
expense = final_expense()['月总支出'].tolist()
saving = [0 for i in range(120)]
debt = [0 for i in range(120)]

def case_e():
    month = []
    data = []
    # 创建两个空列表，用于存放月份和每月数据
    
    for i in range(120):
        money = saving[i] + income[i] - debt[i] - expense[i]  # 当月还需借贷花呗金额 = 月初余额 + 月收入 - 月支出 - 本月需还花呗
        #print(money)
        if -money > 15000:
            # 当月还需借贷花呗金额大于15000元时 → 破（吃）产（土）
            print('第%i个月花呗也救不了我了，要破（吃）产（土）了！\n-------' % (i+1))
            break
        else:
            # 当月还需借贷花呗金额小于等于15000元时 → 继续浪
            if money >= 0:
                saving[i+1] = saving[i] + income[i] - expense[i] - debt[i]
                debt[i+1] = 0
            else:
                money_per = (abs(money) * (1+0.088))/12    # 分期十二月
                saving[i+1] = 0
                debt[i+1] = debt[i+1] + money_per
                debt[i+2] = debt[i+2] + money_per
                debt[i+3] = debt[i+3] + money_per
                debt[i+4] = debt[i+4] + money_per
                debt[i+5] = debt[i+5] + money_per
                debt[i+6] = debt[i+6] + money_per
                debt[i+7] = debt[i+7] + money_per
                debt[i+8] = debt[i+8] + money_per
                debt[i+9] = debt[i+9] + money_per
                debt[i+10] = debt[i+10] + money_per
                debt[i+11] = debt[i+11] + money_per
                debt[i+12] = debt[i+12] + money_per
        month.append(i+1)
        data.append([income[i],expense[i],debt[i],saving[i+1],debt[i+1]])
    # 创建循环，模拟每月花呗使用情况
    
    result_e = pd.DataFrame(data,columns=['月收入','月支出','本月需还花呗','本月余钱','欠债'],index = month)
    result_e.index.name = '月份'
    # 将数据存为Dataframe
    
    return result_e

case_e()

在这里插入图片描述

# 第二回合：允许分期(分期三月)

month_case_b = []    
for i in range(10000): 
    print('正在进行第%i次模拟' % (i+1))
    income = final_income(10000,1500)['月净收入'].tolist()
    expense = final_expense()['月总支出'].tolist()
    saving = [0 for i in range(120)]
    debt = [0 for i in range(120)]
    result_b = case_b().index.max()
    month_case_b.append(result_b)

result_b = pd.Series(month_case_b)

在这里插入图片描述

# 第二回合：允许分期(分期六月)

month_case_c = []    
for i in range(10000): 
    print('正在进行第%i次模拟' % (i+1))
    income = final_income(10000,1500)['月净收入'].tolist()
    expense = final_expense()['月总支出'].tolist()
    saving = [0 for i in range(120)]
    debt = [0 for i in range(120)]
    result_c = case_c().index.max()
    month_case_c.append(result_c)

result_c = pd.Series(month_case_c)

在这里插入图片描述

# 第二回合：允许分期(分期九月)

month_case_d = []    
for i in range(10000): 
    print('正在进行第%i次模拟' % (i+1))
    income = final_income(10000,1500)['月净收入'].tolist()
    expense = final_expense()['月总支出'].tolist()
    saving = [0 for i in range(120)]
    debt = [0 for i in range(120)]
    result_d = case_d().index.max()
    month_case_d.append(result_d)

result_d = pd.Series(month_case_d)

在这里插入图片描述

# 第二回合：允许分期(分期十二月)

month_case_e = []    
for i in range(10000): 
    print('正在进行第%i次模拟' % (i+1))
    income = final_income(10000,1500)['月净收入'].tolist()
    expense = final_expense()['月总支出'].tolist()
    saving = [0 for i in range(120)]
    debt = [0 for i in range(120)]
    result_e = case_e().index.max()
    month_case_e.append(result_e)

result_e = pd.Series(month_case_e)

在这里插入图片描述

# 基于10000次模拟的破（吃）产（土）月份，制作直方图 - 分期三月

plt.figure(figsize = (12,4))
result_b.hist(bins=18)
plt.title('第二回合：允许分期(分期三月) - 模拟结果')

在这里插入图片描述

# 基于10000次模拟的破（吃）产（土）月份，制作直方图 - 分期六月

plt.figure(figsize = (12,4))
result_c.hist(bins=20)
plt.title('第二回合：允许分期(分期六月) - 模拟结果')

在这里插入图片描述

# 基于10000次模拟的破（吃）产（土）月份，制作直方图 - 分期九月

plt.figure(figsize = (12,4))
result_d.hist(bins=20)
plt.title('第二回合：允许分期(分期九月) - 模拟结果')

在这里插入图片描述

# 基于10000次模拟的破（吃）产（土）月份，制作直方图 - 分期十二月

plt.figure(figsize = (12,4))
result_e.hist(bins=20)
plt.title('第二回合：允许分期(分期十二月) - 模拟结果')

在这里插入图片描述

4、“用了花呗会怎么样？” —— 用花呗的不同情况下，看看偿还额度的变化

# 查看数据

income = final_income(10000,1500)['月净收入'].tolist()
expense = final_expense()['月总支出'].tolist()
saving = [0 for i in range(120)]
debt = [0 for i in range(120)]
r1 = case_a()['欠债']

income = final_income(10000,1500)['月净收入'].tolist()
expense = final_expense()['月总支出'].tolist()
saving = [0 for i in range(120)]
debt = [0 for i in range(120)]
r2 = case_b()['欠债']

income = final_income(10000,1500)['月净收入'].tolist()
expense = final_expense()['月总支出'].tolist()
saving = [0 for i in range(120)]
debt = [0 for i in range(120)]
r3 = case_c()['欠债']

income = final_income(10000,1500)['月净收入'].tolist()
expense = final_expense()['月总支出'].tolist()
saving = [0 for i in range(120)]
debt = [0 for i in range(120)]
r4 = case_d()['欠债']

income = final_income(10000,1500)['月净收入'].tolist()
expense = final_expense()['月总支出'].tolist()
saving = [0 for i in range(120)]
debt = [0 for i in range(120)]
r5 = case_e()['欠债']

df = pd.DataFrame({'不分期':r1,'分期三月':r2,'分期六月':r3,'分期九月':r4,'分期十二月':r5},
                 columns = ['不分期','分期三月','分期六月','分期九月','分期十二月'])
df
# 将不同情况的数据连接进行合并

在这里插入图片描述

# 制作折线图

df.plot(kind='line',style = '--.',alpha = 0.8,use_index = True,figsize = (12,4),legend = True,colormap = 'Accent')
plt.title('不同情况下负债积累')
plt.grid()

在这里插入图片描述

一些结论

  • 分期时间越长，可以尽情挥霍不吃土的时间就越长，表明通过透支、借贷，能够大大延缓面临吃土的时间
  • 当收入无法良好匹配“较高生活水平”时，用花呗可以延长时间，但负债将一直积累

所以，使用花呗是可以的，但要适当合理，更重要的是如何提高收入，来更好匹配自己想要的生活

猜你喜欢

转载自blog.csdn.net/weixin_44510615/article/details/89299365
今日推荐
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
周排行
返回指定时间格式
fopen函数中的mode参数
Java 单例模式探讨
Flex remoteobject工作原理探讨
寻找mplayer的便捷安装方法
30天了解30种技术系列---(26)MySQL自动化运维工具Inception
关于Jboss/Tomcat/Jetty的JNDI定义123
程序减肥，strip，eu-strip 及其符号表
AsyncTask、View.post(Runnable)、ViewTreeObserver三种方式总结frame animation自动启动
Json和Bean的互相转换
每日归档
更多
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022