The Ultimate Guide to Smart Investment Planning and Wealth Withdrawal Using Python

Investing can be one of the most powerful ways to secure your financial future, but it comes with a maze of decisions: how much to invest, where to invest, and how to manage withdrawals when the time comes. Wouldn’t it be great to have a tool that helps you model your financial future, factoring in growth rates, inflation, and taxes? While we can't predict the market, we can use Python to build an investment simulator that brings clarity to your planning.

In this blog, we’ll explore how a simple yet powerful Python script can simulate your investments over time, handle tax implications, and help you understand how long your savings will last. By the end of this post, you'll have the tools to make informed financial decisions and visualize your investment outcomes.

We're exploring a strategic approach to building lasting wealth: invest consistently for a few years with annual increments, let your investments grow, and then strategically sell them when you’re ready to stop working. While selling incurs taxes, this marks the transition to a new phase—retirement—where you live off your withdrawals. At this point, you can reinvest your gains into safer assets, like debt or large-cap funds, which offer reduced but stable earnings. With a target monthly income in mind, the plan is to withdraw an inflation-adjusted amount each month, continually adjusting to ensure your lifestyle is sustained as long as possible, until the funds eventually run out or you die.

Why Investment Planning Is Essential

Before diving into the code, let’s talk about why investment planning is crucial. You may think simply putting your money into a savings account or investing without a strategy is good enough, but this approach can have consequences:

The Power of Compound Growth: Small, consistent investments can snowball into a significant sum over time, thanks to compounding. However, to fully realize this power, you need to invest strategically.
Combating Inflation: Inflation erodes the purchasing power of money, meaning what you can buy today with a given amount will likely cost more in the future. Planning for inflation ensures your investments outpace these rising costs.
Tax Efficiency: Taxes can significantly impact your investment returns. Proper planning minimizes tax liabilities, allowing you to retain more of your hard-earned gains.
Sustainable Withdrawals: For retirees or those planning to live off their investments, knowing how much you can withdraw each year without depleting your funds is critical.

This Python investment simulator addresses all these factors, giving you a comprehensive view of your financial future.

The Core Components of the Python Script

Our investment simulator models your financial journey from the accumulation phase (where you’re building wealth) to the decumulation phase (where you’re withdrawing funds). Here’s an in-depth look at how the script works:

Constants and Setup

The script starts by defining important constants, such as the number of months in a year and the formulas for monthly growth and inflation rates:

months_per_year = 12
max_csv_months = 100 * months_per_year  # Limit CSV output to 100 years
annual_return_rate = annual_return_percent / 100
monthly_growth_rate = (1 + annual_return_rate) ** (1 / months_per_year) - 1
annual_inflation_rate = annual_inflation_percent / 100

These constants ensure our calculations are precise and reflect real-world financial dynamics.

Customizing Your Investment Strategy

One of the most exciting aspects of this Python code is that you can tailor it to match your financial situation and goals. Here are the key parameters you can adjust:

Initial Monthly Investment
```
 initial_monthly_investment = 130000  # in currency units
```
- This is the amount you invest every month. Adjust it based on your income and how much you’re willing to allocate for long-term growth.
Yearly Increment Percentage
```
 yearly_increment_percent = 2  # Annual increase in your monthly investment
```
- As your income grows, you might increase your monthly investment. This parameter models that growth. For example, if you expect a 5% annual salary raise, you might increase your contributions accordingly.
Annual Return Percentage
```
 annual_return_percent = 17  # Expected annual return on your investment
```
- This rate varies depending on your investment strategy. Stocks typically offer higher returns (but with more risk), while bonds are safer but yield less.
Number of Years to Invest
```
 years = 12  # Duration of the accumulation phase
```
- Set this to the number of years you plan to invest before making withdrawals. Longer investment horizons generally yield better returns due to compounding.
Annual Inflation Percentage
```
 annual_inflation_percent = 5  # Expected inflation rate
```
- Inflation reduces the purchasing power of your money. This parameter helps simulate how much you’ll need to withdraw in the future to maintain your current lifestyle.
Desired Monthly Amount in Hand
```
 desired_monthly_in_hand = 100000  # Amount needed each month in today's money
```
- This is the amount you’ll need each month during retirement or the withdrawal phase. The code adjusts this amount for inflation, ensuring your purchasing power remains consistent.
Withdrawal Fund Growth Percentage
```
 withdrawal_fund_growth_percent = 8  # Annual return during the withdrawal phase
```
- Even when you start withdrawing funds, your remaining investments will likely continue to grow. This parameter models the expected return during the withdrawal phase.
LTCG and STCG Tax Percentages
```
 ltcg_tax_percent = 12.5  # Tax on long-term gains
 stcg_tax_percent = 20  # Tax on short-term gains
```
- Different types of gains are taxed differently. Adjust these values to match your local tax regulations.

The Investment Phase: Building Your Wealth

The code simulates monthly investments over several years, adjusting for annual increments. Each investment is treated as a separate “lot” to simplify tax calculations later.

for year in range(1, years + 1):
    for month in range(months_per_year):
        lot_name = f"{calendar.month_name[current_month]} {current_year}"
        total_invested_amount += monthly_investment
        investment_lots.append([lot_name, monthly_investment, monthly_investment, 0])

        # Compounding growth
        for lot in investment_lots:
            lot[2] *= (1 + monthly_growth_rate)
            lot[3] += 1

Each lot grows at the monthly rate, simulating the compounding effect that makes investing so powerful. The result is a growing investment balance that can fund your future withdrawals.

Handling Taxes: LTCG and STCG

When it’s time to start withdrawing, the script first sells all investments and calculates taxes. Investments held for over 12 months incur LTCG taxes, while those held for less incur STCG taxes.

while investment_lots:
    lot_name, principal_component, current_value, age = investment_lots.popleft()
    profit = current_value - principal_component
    if age >= 12:
        initial_ltcg_tax += profit * ltcg_tax_rate if profit > 0 else 0
    else:
        initial_stcg_tax += profit * stcg_tax_rate if profit > 0 else 0

This step ensures that your net proceeds after taxes are as accurate as possible, helping you understand your actual available funds.

The Withdrawal Phase: Sustaining Your Wealth

The most critical part of any financial plan is ensuring your money lasts. Our code simulates monthly withdrawals adjusted for inflation, ensuring your lifestyle remains consistent.

monthly_withdrawal = gross_monthly_withdrawal
withdrawal_months = 0

# Adjust withdrawals for inflation and grow the remaining fund
while withdrawal_months < max_csv_months:
    if fund_balance < monthly_withdrawal:
        # If funds are insufficient, sell everything and calculate taxes
        ...
    else:
        # Withdraw the target amount, prioritizing older lots for tax efficiency
        ...
    monthly_withdrawal *= (1 + annual_inflation_rate / 12)

The withdrawal strategy prioritizes selling older lots to minimize taxes and adjusts the withdrawal amount for inflation each month.

A Comprehensive Financial Report

The script generates a detailed summary and a CSV report that captures your financial journey month by month. Here’s what you’ll see in the output:

Investment Summary: How much you invested, the annual return, and the total value when you started withdrawing.
Tax Summary: A breakdown of LTCG and STCG taxes, both at the start of withdrawals and over time.
Duration of Funds: How many years and months your money will last, even with inflation-adjusted withdrawals.

Example Output

You invested 1.30 lacs INR per month for 12 years, which grew at 17% per year.
Your investments increased at 2% per year.
The value of the fund when you stopped investing and started withdrawing
was 5.53 crore INR and 3.08 crore INR adjusted for inflation.
You sold all the funds and incurred 48.92 lacs INR in LTCG and
29.37 thousand INR in STCG, totaling 49.22 lacs INR.
We reinvested the remaining 5.53 crore INR into 100 different lots,
which will grow at 8% per year, and started withdrawing.
You need 1.00 lacs INR per month in today's money.
The starting withdrawal will be 1.80 lacs INR adjusted for
12 years of inflation at 5% per year.
The withdrawals will increase every month to adjust for inflation.

The fund lasted for 34 years and 5 months in the withdrawal phase.

Summary of Taxes:
Initial LTCG Tax at the start of withdrawal: 48.92 lacs INR
Initial STCG Tax at the start of withdrawal: 29.37 thousand INR
LTCG Tax during systematic withdrawals: 2.13 crore INR
STCG Tax during systematic withdrawals: 14.58 thousand INR
Total LTCG Tax (bulk sale + withdrawals): 2.62 crore INR
Total STCG Tax (bulk sale + withdrawals): 43.95 thousand INR

Imagine investing consistently from the age of 30 to 42, dedicating just 12 years to building your financial foundation. With the power of compounding and strategic planning, that relatively short investment period can set you up for a life of financial freedom, allowing you to comfortably retire and sustain yourself until the age of 75. By the time you reach 42, your carefully managed investments could have grown into a massive fund that not only supports your desired lifestyle but also adjusts for inflation, ensuring your wealth retains its purchasing power over the decades.

This means you can enjoy the fruits of your labor, experience peace of mind, and make the most of your golden years without financial stress—all because you committed to investing smartly for just 12 impactful years. The path to early retirement and a worry-free future may be simpler and more attainable than you think!

The CSV File: A Comprehensive Record of Your Financial Journey

One of the most valuable outputs of this Python script is a detailed CSV report. The file contains all the data you need to analyze your investment and withdrawal plan in depth, making it perfect for tracking, planning, or even sharing with your financial advisor.

What’s Inside the CSV File?

The CSV file includes the following columns:

Month: The total number of months since you started investing. This helps you keep track of the timeline and correlate it with your life plans.
Fund Balance: The total value of your investments at the end of each month. It includes the compounded growth from your monthly contributions during the investment phase and the reduced balance during the withdrawal phase.
Investment That Month: The amount you invested in that particular month. During the investment phase, this value is your monthly contribution. Once the investment phase ends, this becomes zero.
Inflation-Adjusted Value: The real value of your fund balance after adjusting for inflation. This column helps you understand the purchasing power of your investments over time, which is crucial for long-term planning.
Gross Withdrawal: The amount you withdrew before accounting for taxes. During the investment phase, this is zero. In the withdrawal phase, it starts with the inflation-adjusted amount you need and increases each month to keep up with inflation.
Taxes to Pay: The taxes incurred on the withdrawn amount. This includes both LTCG and STCG taxes, and it is calculated based on the age of the lots you’re withdrawing from.
Net Withdrawal: The amount you receive after taxes are deducted. This is the money you have in hand to spend, making it an essential metric for planning your lifestyle.
Total Invested Amount: A running total of all the money you have invested over time. This helps you track how much of your wealth is the result of your contributions versus the returns on your investments.
Lots Sold: Detailed information about the investment lots you sold in that month. Each lot includes:
- Lot Name: The month and year when the lot was created.
- Value Sold: How much of the lot was sold.
- Left: The remaining value of the lot after the sale.
- Profit: The profit made from the sale.
- Tax: The tax paid on that profit, either as LTCG or STCG, depending on how long the lot was held.

How to Use the CSV File

The CSV report provides a granular look at your financial journey and can be incredibly helpful in various ways:

Analyze Investment Growth: By reviewing the “Fund Balance” and “Inflation-Adjusted Value” columns, you can see how your investments grow over time and understand the real purchasing power of your wealth.
Track Contributions: The “Investment That Month” and “Total Invested Amount” columns help you keep an eye on your total contributions, making it easy to compare them with the returns you’ve earned.
Plan Withdrawals: The “Gross Withdrawal” and “Net Withdrawal” columns show how much money you’ll have in hand each month, helping you budget for future expenses.
Understand Tax Implications: Taxes can have a significant impact on your withdrawals. The “Taxes to Pay” and “Lots Sold” columns give you a clear picture of how taxes affect your income, allowing you to plan for tax-efficient withdrawals.
Evaluate Financial Milestones: You can pinpoint specific months where major changes occur, such as the start of withdrawals or significant tax events. This is useful for aligning your financial plan with life milestones like retirement, buying a house, or funding education.

Experimenting with Different Scenarios

The flexibility of this simulator allows you to model various financial situations:

Early Retirement: Adjust the number of years to invest to see how long your funds will last if you retire early.
Higher or Lower Inflation: Experiment with different inflation rates to understand how rising costs affect your future withdrawals.
Aggressive vs. Conservative Returns: Simulate both high-risk, high-reward strategies and safer, lower-return investments to see how each impacts your wealth.

Take Control of Your Financial Future

Investing and planning for the future can be daunting, but with tools like this Python simulator, you can make data-driven decisions. By tweaking the parameters, you can explore various scenarios and understand the long-term impact of your investment choices.

So, why wait? Run the simulation, explore different strategies, and set yourself on the path to financial security. Remember, the best time to start investing was yesterday; the second-best time is today. Happy investing, and may your financial future be as bright as you’ve always dreamed!

Full Code

import csv
from collections import deque
import calendar

def calculate_investment_with_withdrawal(
        initial_lumpsum_investment,
        initial_monthly_investment, yearly_increment_percent, annual_return_percent,
        years, annual_inflation_percent, desired_monthly_in_hand, withdrawal_fund_growth_percent,
        ltcg_tax_percent, stcg_tax_percent,
        sell_and_reinvest_at_withdrawal_start  # New boolean parameter
        ):

    # Constants
    months_per_year = 12
    max_csv_months = 100 * months_per_year  # Limit CSV output
    annual_return_rate = annual_return_percent / 100
    # Monthly growth rate during the investment phase
    investment_phase_monthly_growth_rate = (1 + annual_return_rate) ** (1 / months_per_year) - 1
    annual_inflation_rate = annual_inflation_percent / 100
    ltcg_tax_rate = ltcg_tax_percent / 100
    stcg_tax_rate = stcg_tax_percent / 100

    # Queue to track each investment as a separate lot
    investment_lots = deque()  # Stores (lot_name, principal_component, current_value, age_in_months)

    # Prepare to collect data for CSV
    csv_data = [["Month", "Fund Balance", "Investment That Month", "Inflation-Adjusted Value",
                 "Gross Withdrawal", "Taxes to Pay", "Net Withdrawal", "Total Invested Amount", "Lots Sold"]]

    # Investment phase
    monthly_investment = initial_monthly_investment
    total_months_investment_phase = 0
    total_invested_amount = 0

    current_year = 2024  # Starting year for lot naming
    current_month = 11   # Starting month: November

    # Add initial lumpsum investment if it exists
    if initial_lumpsum_investment > 0:
        lumpsum_lot_name = f"Initial Lumpsum ({calendar.month_name[current_month]} {current_year})"
        investment_lots.append([lumpsum_lot_name, initial_lumpsum_investment, initial_lumpsum_investment, 0])
        total_invested_amount += initial_lumpsum_investment

    for year_num in range(1, years + 1):
        for month_num in range(months_per_year):
            total_months_investment_phase += 1

            sip_lot_name = f"SIP {calendar.month_name[current_month]} {current_year}"
            total_invested_amount += monthly_investment
            investment_lots.append([sip_lot_name, monthly_investment, monthly_investment, 0]) # New lot starts with age 0

            # Apply monthly growth and age all lots
            for lot in investment_lots:
                lot[2] *= (1 + investment_phase_monthly_growth_rate)
                lot[3] += 1

            fund_balance_inv_phase = sum(lot[2] for lot in investment_lots)
            inflation_adj_balance_inv_phase = fund_balance_inv_phase / ((1 + annual_inflation_rate) ** (total_months_investment_phase / months_per_year))

            csv_data.append([total_months_investment_phase, f"{fund_balance_inv_phase:.2f}", f"{monthly_investment:.2f}",
                             f"{inflation_adj_balance_inv_phase:.2f}", "0.00", "0.00", "0.00",
                             f"{total_invested_amount:.2f}", ""])

            current_month += 1
            if current_month > 12:
                current_month = 1
                current_year += 1
        # Increase monthly SIP investment for the next year
        monthly_investment *= (1 + yearly_increment_percent / 100)

    # --- Transition to Withdrawal Phase ---
    fund_value_at_switch_pre_tax = sum(lot[2] for lot in investment_lots) # Fund value before any decision at switch

    initial_ltcg_tax_at_switch = 0
    initial_stcg_tax_at_switch = 0
    post_tax_proceeds_at_switch = fund_value_at_switch_pre_tax # Default if no sale

    if sell_and_reinvest_at_withdrawal_start:
        # All existing lots are sold, taxes paid, and proceeds reinvested.
        # `investment_lots` will be consumed and then repopulated.

        processed_fund_value_at_switch = 0 # To verify sum if needed

        # Create a temporary list to process for tax calculation, as investment_lots will be cleared
        lots_to_sell_at_switch = list(investment_lots)
        investment_lots.clear() # Original lots will be replaced

        for lot_name, principal_component, current_value, age in lots_to_sell_at_switch:
            processed_fund_value_at_switch += current_value # This is the pre-tax value of each lot
            profit = current_value - principal_component
            tax_on_lot = 0

            if profit > 0:
                if age >= 12: # LTCG
                    tax_on_lot = profit * ltcg_tax_rate
                    initial_ltcg_tax_at_switch += tax_on_lot
                else: # STCG
                    tax_on_lot = profit * stcg_tax_rate
                    initial_stcg_tax_at_switch += tax_on_lot

        # fund_value_at_switch_pre_tax was already calculated by sum() before this block
        initial_total_tax_at_switch = initial_ltcg_tax_at_switch + initial_stcg_tax_at_switch
        post_tax_proceeds_at_switch = fund_value_at_switch_pre_tax - initial_total_tax_at_switch

        if post_tax_proceeds_at_switch > 0:
            new_lot_value = post_tax_proceeds_at_switch / 100
            for i in range(100):
                 investment_lots.append([f"ReinvestLot-{i + 1}", new_lot_value, new_lot_value, 0])
        # If post_tax_proceeds is zero or negative, investment_lots remains empty.

        withdrawal_phase_monthly_growth_rate = (1 + (withdrawal_fund_growth_percent / 100)) ** (1 / months_per_year) - 1
        growth_rate_info_for_print = f"{withdrawal_fund_growth_percent}% (on newly reinvested fund)"
        switch_action_description = (
            f"At the end of {years} years, the total value of your fund before tax was {format_in_lacs_and_crores(fund_value_at_switch_pre_tax)}.\n"
            f"All holdings were sold. An initial LTCG tax of {format_in_lacs_and_crores(initial_ltcg_tax_at_switch)} and STCG tax of {format_in_lacs_and_crores(initial_stcg_tax_at_switch)} were incurred.\n"
            f"Total tax paid at this point: {format_in_lacs_and_crores(initial_total_tax_at_switch)}.\n"
            f"The remaining amount of {format_in_lacs_and_crores(post_tax_proceeds_at_switch)} was reinvested into 100 fresh lots."
        )
    else:
        # Original lots are carried over. No bulk sale, no initial tax at switch.
        # initial_ltcg_tax_at_switch, initial_stcg_tax_at_switch remain 0.
        # post_tax_proceeds_at_switch equals fund_value_at_switch_pre_tax.
        # `investment_lots` still contains the original lots from the investment phase.
        withdrawal_phase_monthly_growth_rate = investment_phase_monthly_growth_rate # Continue with original investment growth rate
        growth_rate_info_for_print = f"{annual_return_percent}% (original investment rate continuing)"
        initial_total_tax_at_switch = 0 # Explicitly zero
        switch_action_description = (
            f"At the end of {years} years, the total value of your fund was {format_in_lacs_and_crores(fund_value_at_switch_pre_tax)}.\n"
            f"No holdings were sold at this point. The existing investments are carried forward into the withdrawal phase.\n"
            f"No initial bulk tax was paid at the start of withdrawal."
        )

    # Inflation adjustment for reporting
    inflation_adjusted_fund_value_at_switch = fund_value_at_switch_pre_tax / ((1 + annual_inflation_rate) ** years)
    # Desired withdrawal amount, inflation-adjusted to the start of withdrawal
    adjusted_desired_monthly_in_hand = desired_monthly_in_hand * ((1 + annual_inflation_rate) ** years)

    # Initial gross monthly withdrawal estimate (assuming LTCG for simplicity, actual tax is per lot sold)
    gross_monthly_withdrawal_estimate = adjusted_desired_monthly_in_hand
    if (1 - ltcg_tax_rate) > 0 : # Avoid division by zero if tax rate is 100%
        gross_monthly_withdrawal_estimate = adjusted_desired_monthly_in_hand / (1 - ltcg_tax_rate)
    elif desired_monthly_in_hand == 0: # If no withdrawal desired, gross is zero
        gross_monthly_withdrawal_estimate = 0
    else: # If tax rate is 100% and desired is non-zero, effectively infinite gross needed
        gross_monthly_withdrawal_estimate = float('inf')

    # --- Withdrawal Phase Logic ---
    monthly_withdrawal_target_gross = gross_monthly_withdrawal_estimate # This target will inflate monthly
    withdrawal_months_elapsed = 0
    current_fund_balance_withdrawal = sum(lot[2] for lot in investment_lots) # Initial balance for withdrawal phase

    total_ltcg_tax_during_withdrawal_phase = 0
    total_stcg_tax_during_withdrawal_phase = 0

    while withdrawal_months_elapsed < max_csv_months and current_fund_balance_withdrawal > 0:
        # 1. Grow all lots and age them
        for lot in investment_lots:
            lot[2] *= (1 + withdrawal_phase_monthly_growth_rate)
            lot[3] += 1

        current_fund_balance_withdrawal = sum(lot[2] for lot in investment_lots) # Update balance after growth
        if current_fund_balance_withdrawal == 0: break # No money left

        # 2. Determine amount to sell for this month's withdrawal
        amount_to_sell_gross_this_month = min(monthly_withdrawal_target_gross, current_fund_balance_withdrawal)

        monthly_tax_paid_this_withdrawal = 0
        lots_sold_details_this_withdrawal = []
        withdrawn_this_month_gross = 0

        # Temporary queue for processing lots for this month's sale (FIFO)
        processing_lots_for_sale = investment_lots 
        investment_lots = deque() # Will be rebuilt with remaining parts and unsold lots

        while amount_to_sell_gross_this_month > 0 and processing_lots_for_sale:
            lot_name, principal_component, current_value, age = processing_lots_for_sale.popleft() # Sell from oldest

            applicable_tax_rate_this_sale = stcg_tax_rate
            tax_label_this_sale = "STCG"
            if age >= 12:
                applicable_tax_rate_this_sale = ltcg_tax_rate
                tax_label_this_sale = "LTCG"

            if current_value <= amount_to_sell_gross_this_month: # Sell entire lot
                profit_on_sale = current_value - principal_component
                tax_on_sale = profit_on_sale * applicable_tax_rate_this_sale if profit_on_sale > 0 else 0
                monthly_tax_paid_this_withdrawal += tax_on_sale

                if tax_label_this_sale == "LTCG": total_ltcg_tax_during_withdrawal_phase += tax_on_sale
                else: total_stcg_tax_during_withdrawal_phase += tax_on_sale

                lots_sold_details_this_withdrawal.append(
                    f"{lot_name} (Age:{age}m): Val={current_value:.2f}, Sold={current_value:.2f}, Left=0.00, "
                    f"Profit={profit_on_sale:.2f}, Tax={tax_label_this_sale}:{tax_on_sale:.2f}"
                )
                amount_to_sell_gross_this_month -= current_value
                withdrawn_this_month_gross += current_value
            else: # Partially sell this lot
                sold_value = amount_to_sell_gross_this_month
                proportion_to_sell = sold_value / current_value
                principal_of_sold_portion = principal_component * proportion_to_sell
                profit_on_sale = sold_value - principal_of_sold_portion

                tax_on_sale = profit_on_sale * applicable_tax_rate_this_sale if profit_on_sale > 0 else 0
                monthly_tax_paid_this_withdrawal += tax_on_sale

                if tax_label_this_sale == "LTCG": total_ltcg_tax_during_withdrawal_phase += tax_on_sale
                else: total_stcg_tax_during_withdrawal_phase += tax_on_sale

                remaining_value = current_value - sold_value
                remaining_principal = principal_component * (1 - proportion_to_sell)

                lots_sold_details_this_withdrawal.append(
                    f"{lot_name} (Age:{age}m): Val={current_value:.2f}, Sold={sold_value:.2f}, Left={remaining_value:.2f}, "
                    f"Profit={profit_on_sale:.2f}, Tax={tax_label_this_sale}:{tax_on_sale:.2f}"
                )
                withdrawn_this_month_gross += sold_value
                # Add the partially remaining lot back to the front of processing_lots_for_sale
                # so it's considered first if more money is needed this month.
                processing_lots_for_sale.appendleft([lot_name, remaining_principal, remaining_value, age])
                amount_to_sell_gross_this_month = 0 # Target met

        # Add any remaining lots (unsold or final partial remainder) from processing_lots_for_sale back to investment_lots
        investment_lots.extend(processing_lots_for_sale)

        net_withdrawal_this_month = withdrawn_this_month_gross - monthly_tax_paid_this_withdrawal
        current_fund_balance_withdrawal = sum(lot[2] for lot in investment_lots) # Update balance after sales

        # Inflation-adjusted fund balance (remaining)
        total_months_from_very_start = total_months_investment_phase + withdrawal_months_elapsed + 1
        inflation_adj_remaining_fund_bal = current_fund_balance_withdrawal / ((1 + annual_inflation_rate) ** (total_months_from_very_start / months_per_year))

        csv_data.append([total_months_investment_phase + withdrawal_months_elapsed + 1, 
                         f"{current_fund_balance_withdrawal:.2f}", "0.00",
                         f"{inflation_adj_remaining_fund_bal:.2f}", f"{withdrawn_this_month_gross:.2f}",
                         f"{monthly_tax_paid_this_withdrawal:.2f}", f"{net_withdrawal_this_month:.2f}",
                         f"{total_invested_amount:.2f}", "; ".join(lots_sold_details_this_withdrawal)])

        withdrawal_months_elapsed += 1
        # Inflate the gross withdrawal target for the next month
        monthly_withdrawal_target_gross *= (1 + annual_inflation_rate / 12)

        if not investment_lots and current_fund_balance_withdrawal <=0 : # Fund depleted
            break

    # Calculate total years and months of withdrawals
    withdrawal_total_years = withdrawal_months_elapsed // 12
    withdrawal_total_remaining_months = withdrawal_months_elapsed % 12

    # Write data to CSV
    with open("investment_withdrawal_report.csv", "w", newline="") as csvfile:
        writer = csv.writer(csvfile)
        writer.writerows(csv_data)

    # --- Print Summary ---
    print(f"\nInvestment Phase:")
    print(f"You started with an initial lumpsum investment of {format_in_lacs_and_crores(initial_lumpsum_investment)}.")
    print(f"You then invested an initial {format_in_lacs_and_crores(initial_monthly_investment)} per month for {years} years.")
    print(f"Your monthly investments increased at {yearly_increment_percent}% per year.")
    print(f"The investments grew at an average of {annual_return_percent}% per year during this phase.")
    print(f"Total amount invested (Lumpsum + SIPs): {format_in_lacs_and_crores(total_invested_amount)}.")

    print(f"\nTransition to Withdrawal Phase:")
    print(switch_action_description) # This contains the conditional explanation

    print(f"\nWithdrawal Phase:")
    print(f"During the withdrawal phase, the fund is projected to grow at {growth_rate_info_for_print}.") # Conditional growth rate info
    print(f"Your desired monthly income in today's money is {format_in_lacs_and_crores(desired_monthly_in_hand)}.")
    print(f"Adjusted for {years} years of inflation at {annual_inflation_percent}%, your first month's target net withdrawal was {format_in_lacs_and_crores(adjusted_desired_monthly_in_hand)}.")
    print(f"To achieve this, the initial gross withdrawal target was estimated at {format_in_lacs_and_crores(gross_monthly_withdrawal_estimate)}.")
    print(f"Withdrawals increase monthly to keep pace with {annual_inflation_percent}% annual inflation.")

    if current_fund_balance_withdrawal <=0 and withdrawal_months_elapsed < max_csv_months :
         print(f"\nThe fund lasted for {withdrawal_total_years} years and {withdrawal_total_remaining_months} months in the withdrawal phase.")
    elif withdrawal_months_elapsed >= max_csv_months:
         print(f"\nThe fund is projected to last for at least {withdrawal_total_years} years and {withdrawal_total_remaining_months} months (simulation limit reached).")
         print(f"Remaining balance at simulation end: {format_in_lacs_and_crores(current_fund_balance_withdrawal)}")

    print(f"\nSummary of Taxes Paid:")
    print(f"  Initial LTCG Tax (at switch): {format_in_lacs_and_crores(initial_ltcg_tax_at_switch)}")
    print(f"  Initial STCG Tax (at switch): {format_in_lacs_and_crores(initial_stcg_tax_at_switch)}")
    print(f"  LTCG Tax (during withdrawals): {format_in_lacs_and_crores(total_ltcg_tax_during_withdrawal_phase)}")
    print(f"  STCG Tax (during withdrawals): {format_in_lacs_and_crores(total_stcg_tax_during_withdrawal_phase)}")
    print(f"  --------------------------------------------------")
    print(f"  Total LTCG Tax (Overall): {format_in_lacs_and_crores(initial_ltcg_tax_at_switch + total_ltcg_tax_during_withdrawal_phase)}")
    print(f"  Total STCG Tax (Overall): {format_in_lacs_and_crores(initial_stcg_tax_at_switch + total_stcg_tax_during_withdrawal_phase)}")
    print(f"  ==================================================")
    total_overall_taxes = initial_ltcg_tax_at_switch + initial_stcg_tax_at_switch + \
                          total_ltcg_tax_during_withdrawal_phase + total_stcg_tax_during_withdrawal_phase
    print(f"  Total Taxes Paid (All Types, All Phases): {format_in_lacs_and_crores(total_overall_taxes)}")

    return (withdrawal_total_years, withdrawal_total_remaining_months, fund_value_at_switch_pre_tax, 
            inflation_adjusted_fund_value_at_switch, adjusted_desired_monthly_in_hand, 
            gross_monthly_withdrawal_estimate, ltcg_tax_rate * 100, stcg_tax_rate * 100)


def format_in_lacs_and_crores(amount):
    if amount is None: return "N/A"
    if amount == float('inf'): return "Effectively Infinite (due to 100% tax)"
    if amount >= 1e7:  # Greater than or equal to 1 crore
        return f"{amount / 1e7:.2f} crore INR"
    elif amount >= 1e5:  # Greater than or equal to 1 lac
        return f"{amount / 1e5:.2f} lacs INR"
    elif amount >= 1e3:  # Greater than or equal to 1 thousand
        return f"{amount / 1e3:.2f} thousand INR"
    else:
        return f"{amount:.2f} INR"


# --- Main execution ---
# Easily adjustable values
initial_lumpsum_investment = 500000
initial_monthly_investment = 50000
yearly_increment_percent = 2
annual_return_percent = 12          # Growth rate during investment phase
years = 10                          # Number of years to invest
annual_inflation_percent = 6
desired_monthly_in_hand = 70000
withdrawal_fund_growth_percent = 8  # Growth rate of NEW fund if sold & reinvested
ltcg_tax_percent = 10               # LTCG tax percentage
stcg_tax_percent = 15               # STCG tax percentage

# New toggle:
# True = Sell all at withdrawal, pay tax, reinvest into new fund growing at withdrawal_fund_growth_percent.
# False = Carry over original investments, no bulk tax at switch, original investments continue growing at annual_return_percent.
sell_and_reinvest_at_withdrawal_start = False

# Perform the calculations
(res_withdrawal_years, res_withdrawal_months, res_fund_val_at_switch,
 res_inf_adj_fund_val_at_switch, res_inf_adj_first_withdrawal,
 res_est_initial_gross_withdrawal, res_ltcg_rate, res_stcg_rate) = \
    calculate_investment_with_withdrawal(
        initial_lumpsum_investment,
        initial_monthly_investment,
        yearly_increment_percent,
        annual_return_percent,
        years,
        annual_inflation_percent,
        desired_monthly_in_hand,
        withdrawal_fund_growth_percent,
        ltcg_tax_percent,
        stcg_tax_percent,
        sell_and_reinvest_at_withdrawal_start # Pass the new flag
    )

# Display the results (summary is now printed within the function)
print("\n_________________________________________________________________________")
print("The detailed monthly report has been saved to 'investment_withdrawal_report.csv'.")
print("The summary of the investment and withdrawal projection is printed above.")
print("_________________________________________________________________________")

The Ultimate Guide to Smart Investment Planning and Wealth Withdrawal Using Python

Comments

More from this blog

Computer Arithmetic: From Fast Adders to Floating-Point

The Complete Memory Hierarchy: From Semiconductor RAM to Virtual Memory

The Ultimate Spring Boot Guide: From Fundamentals to Production-Ready REST APIs

Understanding Functions, Memory, and Pointers in C: A Complete Guide

Datapath and Control

Why Investment Planning Is Essential

The Core Components of the Python Script

Constants and Setup

Customizing Your Investment Strategy

The Investment Phase: Building Your Wealth

Handling Taxes: LTCG and STCG

The Withdrawal Phase: Sustaining Your Wealth

A Comprehensive Financial Report

Example Output

The CSV File: A Comprehensive Record of Your Financial Journey

What’s Inside the CSV File?

How to Use the CSV File

Experimenting with Different Scenarios

Take Control of Your Financial Future

Full Code

Command Palette

Comments

More from this blog

Why Investment Planning Is Essential

The Core Components of the Python Script

Constants and Setup

Customizing Your Investment Strategy

The Investment Phase: Building Your Wealth

Handling Taxes: LTCG and STCG

The Withdrawal Phase: Sustaining Your Wealth

A Comprehensive Financial Report

Example Output

The CSV File: A Comprehensive Record of Your Financial Journey

What’s Inside the CSV File?

How to Use the CSV File

Experimenting with Different Scenarios

Take Control of Your Financial Future

Full Code