AliBina, نویسنده در لرن سرا

Rule of 72 – Useful code

Ever heard of the Rule of 72? It’s a classic finance shortcut that tells you how many years it takes for an investment to double at a given interest rate—without reaching for a calculator! Pretty much, if you want to understand when you are going to double your money, that are growing with 7% per year, then simply divide 72 by 7 and see the approximate answer. It works like that and it is approximately ok, for values between 5 and 10%.

For all other values, the formula looks like this:

ln(2) is approximately 0.693. Hence, it is 0.693 divided by ln(1+tiny percentage).

With Python the formula looks like this:

import math def exact_doubling_time(rate_percent): rate_decimal = rate_percent / 100.0 return math.log(2)/math.log(1+rate_decimal)

import math

def exact_doubling_time(rate_percent):

rate_decimal = rate_percent / 100.0

return math.log(2)/math.log(1+rate_decimal)

If you want to see how exact the formula is, then a good comparison vs the exact value looks like this:

def rule_of_72(rate_percent): return 72 / rate_percent def rule_of_70(rate_percent): return 70 / rate_percent def rule_of_69(rate_percent): return 69 / rate_percent rate_ex = 8 approx_72 = rule_of_72(rate_ex) approx_70 = rule_of_70(rate_ex) approx_69 = rule_of_69(rate_ex) exact_val = exact_doubling_time(rate_ex) print(f”Interest Rate: {rate_ex}%”) print(f”Rule of 72: {approx_72:.2f} years”) print(f”Rule of 70: {approx_70:.2f} years”) print(f”Rule of 69: {approx_69:.2f} years”) print(f”Exact: {exact_val:.3f} years”) for r_percent in [1, 2, 5, 8, 10, 20]: exact_t = exact_doubling_time(r_percent) t72 = rule_of_72(r_percent) print(f”Rate: {r_percent}%\n” f” Exact = {exact_t:.3f} | Rule 72 = {t72:.3f} | Error = {100*(t72 – exact_t)/exact_t:.2f}%\n”)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

def rule_of_72(rate_percent):

return 72 / rate_percent

def rule_of_70(rate_percent):

return 70 / rate_percent

def rule_of_69(rate_percent):

return 69 / rate_percent

rate_ex = 8

approx_72 = rule_of_72(rate_ex)

approx_70 = rule_of_70(rate_ex)

approx_69 = rule_of_69(rate_ex)

exact_val = exact_doubling_time(rate_ex)

print(f“Interest Rate: {rate_ex}%”)

print(f“Rule of 72: {approx_72:.2f} years”)

print(f“Rule of 70: {approx_70:.2f} years”)

print(f“Rule of 69: {approx_69:.2f} years”)

print(f“Exact: {exact_val:.3f} years”)

for r_percent in [1, 2, 5, 8, 10, 20]:

exact_t = exact_doubling_time(r_percent)

t72 = rule_of_72(r_percent)

print(f“Rate: {r_percent}%\n”

f” Exact = {exact_t:.3f} | Rule 72 = {t72:.3f} | Error = {100*(t72 – exact_t)/exact_t:.2f}%\n”)

The execution of the code from above like this:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

Interest Rate: 8%

Rule of 72: 9.00 years

Rule of 70: 8.75 years

Rule of 69: 8.62 years

Exact: 9.006 years

Rate: 1%

Exact = 69.661 | Rule 72 = 72.000 | Error = 3.36%

Rate: 2%

Exact = 35.003 | Rule 72 = 36.000 | Error = 2.85%

Rate: 5%

Exact = 14.207 | Rule 72 = 14.400 | Error = 1.36%

Rate: 8%

Exact = 9.006 | Rule 72 = 9.000 | Error = –0.07%

Rate: 10%

Exact = 7.273 | Rule 72 = 7.200 | Error = –1.00%

Rate: 20%

Exact = 3.802 | Rule 72 = 3.600 | Error = –5.31%

The YT video, explaining the code and is here:

https://www.youtube.com/watch?v=BURstTrQWkA

The GitHub code is here: https://github.com/Vitosh/Python_personal/tree/master/YouTube/023_Python-Rule-of-72

A nice picture from Polovrak Peak, Bulgaria

Enjoy!

Source link

می 11, 2025

Rules of 114 and 144 – Useful code

The Rule of 114 is a quick way to estimate how long it will take to triple your money with compound interest. The idea is simple: divide 114 by the annual interest rate (in %), and you will get an approximate answer in years.

If you earn 10% annually, the time to triple your money is approximately:

Similarly, the Rule of 144 works for quadrupling your money. Divide 144 by the annual interest rate to estimate the time.

At 10% annual growth, the time to quadruple your money is:

Why Do These Rules Work?

These rules are approximations based on the exponential nature of compound interest. While they are not perfectly accurate for all rates, they are great for quick mental math, especially for interest rates in the 5–15% range. While the rules are convenient, always use the exact formula when accuracy matters!

Exact Formulas?

For precise calculations, use the exact formula based on logarithms:

To triple your money:
To quadruple your money:

These rules for 4x or 3x can be summarized with the following python formula:

def exact_time_for_multiplier(n, rate_percent): rate_decimal = rate_percent / 100 return math.log(n) / math.log(1 + rate_decimal) # Example: Growing your money 10x n = 10 rate = 8 # 8% annual interest exact_time = exact_time_for_multiplier(n, rate) print(f”Exact time to grow money {n}x at {rate}% interest: {exact_time:.2f} years”)

def exact_time_for_multiplier(n, rate_percent):

rate_decimal = rate_percent / 100

return math.log(n) / math.log(1 + rate_decimal)

# Example: Growing your money 10x

n = 10

rate = 8 # 8% annual interest

exact_time = exact_time_for_multiplier(n, rate)

print(f“Exact time to grow money {n}x at {rate}% interest: {exact_time:.2f} years”)

Generally, these rules are explained a bit into more details in the video, below:

https://www.youtube.com/watch?v=iDcPdcKi-oI

The GitHub repository is here: https://github.com/Vitosh/Python_personal/tree/master/YouTube/024_Python-Rule-of-114

Enjoy it! 🙂

Source link

می 11, 2025

Trigonometric Functions – Sine – Useful code

import numpy as np

import matplotlib.pyplot as plt

import matplotlib.animation as animation

# Generate unit circle points

theta = np.linspace(0, 2 * np.pi, 1000)

x_circle = np.cos(theta)

y_circle = np.sin(theta)

# Initialize figure

fig, ax = plt.subplots(figsize=(8, 8))

ax.plot(x_circle, y_circle, ‘b-‘, label=“Unit Circle”) # Unit circle

ax.axhline(0, color=“gray”, linestyle=“dotted”)

ax.axvline(0, color=“gray”, linestyle=“dotted”)

# Add dynamic triangle components

triangle_line, = ax.plot([], [], ‘r-‘, linewidth=2, label=“Triangle Sides”)

point, = ax.plot([], [], ‘ro’) # Moving point on the circle

# Text for dynamic values

dynamic_text = ax.text(0.03, 0.03, “”, fontsize=12, color=“black”, ha=“left”, transform=ax.transAxes)

# Set up axis limits and labels

ax.set_xlim(–1.2, 1.2)

ax.set_ylim(–1.2, 1.2)

ax.set_title(“Sine as a Triangle on the Unit Circle”, fontsize=14)

ax.set_xlabel(“cos(θ)”, fontsize=12)

ax.set_ylabel(“sin(θ)”, fontsize=12)

ax.legend(loc=“upper left”)

# Animation update function

def update(frame):

angle = theta[frame]

x_point = np.cos(angle)

y_point = np.sin(angle)

degrees = np.degrees(angle) % 360 # Convert radians to degrees

# Update triangle

triangle_line.set_data([0, x_point, x_point, 0], [0, y_point, 0, 0])

# Update point on the circle

point.set_data([x_point], [y_point]) # Fixed this line to avoid the warning

# Update text for angle, opposite side length, and sin(θ)

dynamic_text.set_text(f“Angle: {degrees:.1f}°\nOpposite Side Length: {y_point:.2f}\nsin(θ): {y_point:.2f}”)

return triangle_line, point, dynamic_text

# Create animation

ani = animation.FuncAnimation(fig, update, frames=len(theta), interval=20, blit=True)

plt.show()

Source link

می 10, 2025

Sine and Cosine – A friendly guide to the unit circle

Welcome to the world of sine and cosine! These two functions are the backbone of trigonometry, and they’re much simpler than they seem. In this article, we will explore the unit circle, the home of sine and cosine, and learn…

VBA – Automated Pivot Filtering – Useful code

Sub FilterPivotTableBasedOnSelectedTeams()

Dim pt As PivotTable

Dim selectedItemsRange As Range

Dim myCell As Range

Dim fieldName As String

Dim lastRowSelected As Long

Dim pi As PivotItem

Dim firstItemSet As Boolean

Set pt = ThisWorkbook.Worksheets(“PivotTable2”).PivotTables(“PivotTable2”)

lastRowSelected = LastRow(tblTemp.Name, 1)

Set selectedItemsRange = tblTemp.Range(“A1:A” & lastRowSelected)

fieldName = “Team”

pt.PivotFields(fieldName).ClearAllFilters

Dim itemsTotal As Long

itemsTotal = pt.PivotFields(fieldName).PivotItems.Count

For Each pi In pt.PivotFields(fieldName).PivotItems

If Not IsInRange(pi.Name, selectedItemsRange) Then

itemsTotal = itemsTotal – 1

If itemsTotal = 0 Then

Err.Raise 222, Description:=“No value in the pivot!”

Exit Sub

End If

pi.Visible = False

End If

Next pi

End Sub

Function IsInRange(myValue As String, myRange As Range) As Boolean

Dim myCell As Range

IsInRange = False

For Each myCell In myRange.Cells

If myCell.value = myValue Then

IsInRange = True

Exit Function

End If

Next myCell

End Function

Public Function LastRow(wsName As String, Optional columnToCheck As Long = 1) As Long

Dim ws As Worksheet

Set ws = ThisWorkbook.Worksheets(wsName)

LastRow = ws.Cells(ws.Rows.Count, columnToCheck).End(xlUp).Row

End Function

Source link

می 8, 2025

Automate Stock Analysis with Python and Yfinance: Generate Excel Reports

In this article, we will explore how to analyze stocks using Python and Excel. We will fetch historical data for three popular stocks—Realty Income (O), McDonald’s (MCD), and Johnson & Johnson (JNJ) — calculate returns, factor in dividends, and visualize…

Python – Data Wrangling with Excel and Pandas – Useful code

Data wrangling with Excel and Pandas is actually quite useful tool in the belt of any Excel professional, financial professional, data analyst or a developer. Really, everyonecan benefit from the well defined libraries that ease people’s lifes. These are the libraries used:

import pandas as pd # Main data manipulation from openpyxl import Workbook # Excel writing from openpyxl.styles import Font # Excel formatting (bold, colors) import glob # File path handling from datetime import datetime

import pandas as pd # Main data manipulation

from openpyxl import Workbook # Excel writing

from openpyxl.styles import Font # Excel formatting (bold, colors)

import glob # File path handling

from datetime import datetime

Additionally, a function for making a unique Excel name is used:

def make_unique_name(): timestamp = datetime.now().strftime(‘%Y%m%d_%H%M%S’) return f'{timestamp}__report.xlsx’

def make_unique_name():

timestamp = datetime.now().strftime(‘%Y%m%d_%H%M%S’)

return f‘{timestamp}__report.xlsx’

An example of the video, where Jupyter Notebook is used.

In the YT video below, the following 8 points are discussed:

# Trick 1 – Simple reading of worksheet from Excel workbook

excel_file_name = “financial_data.xlsx” df = pd.read_excel(excel_file_name, sheet_name = “Transactions”, parse_dates = [“Date”], dtype={“InvoiceID”:str})

excel_file_name = “financial_data.xlsx”

df = pd.read_excel(excel_file_name,

sheet_name = “Transactions”,

parse_dates = [“Date”],

dtype={“InvoiceID”:str})

# Trick 2 – Combine Reports

income = pd.read_excel(excel_file_name, sheet_name=”Income”) expenses = pd.read_excel(excel_file_name, sheet_name=”Expenses”) combined = pd.concat([ income.assign(From_Worksheet=”Income”), expenses.assign(From_Worksheet=”Expenses”) ])

income = pd.read_excel(excel_file_name, sheet_name=“Income”)

expenses = pd.read_excel(excel_file_name, sheet_name=“Expenses”)

combined = pd.concat([

income.assign(From_Worksheet=“Income”),

expenses.assign(From_Worksheet=“Expenses”)

])

# Trick 3 – Fix Missing Values

combined[“Amount”] = combined[“Amount”].fillna(combined[“Amount”].mean())

combined[“Amount”] = combined[“Amount”].fillna(combined[“Amount”].mean())

# Trick 4 – Formatting the exported Excel file

with pd.ExcelWriter(new_worksheet, engine=”openpyxl”) as writer: combined.to_excel(writer, index=False) workbook = writer.book worksheet=writer.sheets[“Sheet1”] for cell in worksheet[“1:1″]: cell.font = Font(bold=True) cell.font = Font(color=”FFFF22”)

with pd.ExcelWriter(new_worksheet, engine=“openpyxl”) as writer:

combined.to_excel(writer, index=False)

workbook = writer.book

worksheet=writer.sheets[“Sheet1”]

for cell in worksheet[“1:1”]:

cell.font = Font(bold=True)

cell.font = Font(color=“FFFF22”)

# Trick 5 – Merging Excel Files

files = glob.glob(“sales12/sales_*.xlsx”) annual_data = pd.concat([pd.read_excel(f) for f in files])

files = glob.glob(“sales12/sales_*.xlsx”)

annual_data = pd.concat([pd.read_excel(f) for f in files])

# Trick 6 – Smart Filtering

web_design_only = annual_data[ (annual_data[“Description”]==”Web Design” )] small_transactions = annual_data[ (annual_data[“Amount”] < 200 )]

web_design_only = annual_data[

(annual_data[“Description”]==“Web Design”

)]

small_transactions = annual_data[

(annual_data[“Amount”] < 200

)]

# Trick 7 – Mergining Tables

df_transactions = pd.read_excel( excel_file_name, sheet_name=”Transactions”) df_customers = pd.read_excel( excel_file_name, sheet_name=”Customers”) merged = pd.merge( df_transactions, df_customers, on = “CustomerID” )

df_transactions = pd.read_excel(

excel_file_name,

sheet_name=“Transactions”)

df_customers = pd.read_excel(

excel_file_name,

sheet_name=“Customers”)

merged = pd.merge(

df_transactions,

df_customers,

on = “CustomerID”

)

# Trick 8 – Export Dataframe to Excel

with pd.ExcelWriter(new_worksheet, engine=”openpyxl”) as writer: merged.to_excel(writer)

with pd.ExcelWriter(new_worksheet, engine=“openpyxl”) as writer:

merged.to_excel(writer)

The whole code with the Excel files is available in GitHub here.

https://www.youtube.com/watch?v=SXXc4WySZS4

Enjoy it!

Source link

می 6, 2025

Python – Monte Carlo Simulation – Useful code

Python can be used for various tasks. One of these is Monte Carlo simulation for future stock analysis. In the video below this is exactly what is happening. 🙂

10K simulations in 30 buckets for KO look like that.

Instead of explaining the video and its code (available also in GitHub), I will concentrate on why it is better to use log returns than simple returns in stock analysis. Which is actually part of the video as well. Below are the 3 main reasons:

1. Time-Additivity

Log returns sum over time, making multi-period calculations effortless. A 10% gain followed by a 10% loss doesn’t cancel out with simple returns—but it nearly does with logs.

2. Symmetry Matters

A +10% and -10% return aren’t true inverses in simple terms. Logs fix this, ensuring consistent math for gains and losses.

3. Better for Modeling

Log returns follow a near-normal distribution, crucial for statistical models like Monte Carlo simulations.

When to Use Simple Returns?

Code Highlights

Source link

می 5, 2025

Python – Reading Financial Data From Internet – Useful code

Reading financial data from the internet is sometimes challenging. In this short article with two python snippets, I will show how to read it from Wikipedia and from and from API, delivering in JSON format:

This is how the financial json data from the api looks like.

Reading the data from the API is actually not tough, if you have experience reading JSON, with nested lists. If not, simply try with trial and error and eventually you will succeed:

import numpy as np import pandas as pd import yfinance as yf import requests from datetime import datetime def get_nasdaq_tickers_from_api(): headers={ “User-Agent”:”Mozilla/5.0″, “Accept”:”application/json” } url = “https://api.nasdaq.com/api/quote/list-type/nasdaq100″ response = requests.get(url, headers=headers, timeout=10) tickers = [item[“symbol”] for item in data[“data”][“data”][“rows”]] return tickers

import numpy as np

import pandas as pd

import yfinance as yf

import requests

from datetime import datetime

def get_nasdaq_tickers_from_api():

headers={

“User-Agent”:“Mozilla/5.0”,

“Accept”:“application/json”

}

url = “https://api.nasdaq.com/api/quote/list-type/nasdaq100”

response = requests.get(url, headers=headers, timeout=10)

tickers = [item[“symbol”] for item in data[“data”][“data”][“rows”]]

return tickers

With the reading from wikipedia, it is actually even easier – the site works flawlessly with pandas, and if you count the tables correctly, you would get what you want:

def get_nasdaq_tickers_from_wikipedia(): wiki_url = “https://en.wikipedia.org/wiki/Nasdaq-100″ tables = pd.read_html(wiki_url) components_table=tables[4] tickers=components_table[“Ticker”].tolist() return tickers

def get_nasdaq_tickers_from_wikipedia():

wiki_url = “https://en.wikipedia.org/wiki/Nasdaq-100”

tables = pd.read_html(wiki_url)

components_table=tables[4]

tickers=components_table[“Ticker”].tolist()

return tickers

You might want to combine both sources, just in case:

tickers = list(set(get_wiki_tickers() + get_nasdaq_api_tickers()))

tickers = list(set(get_wiki_tickers() + get_nasdaq_api_tickers()))

The YouTube video for this article is here:
https://www.youtube.com/watch?v=Uj95BgimHa8
The GitHub code is there – GitHub

Enjoy it! 🙂

Source link

می 4, 2025

Python – Simple Stock Analysis with yfinance – Useful code

Sometimes, the graphs of stocks are useful. Sometimes these are not. In general, do your own research, none of this is financial advice.

And while doing that, if you want to analyze stocks with just a few lines of python, this article might help? This simple yet powerful script helps you spot potential buy and sell opportunities for Apple (AAPL) using two classic technical indicators: moving averages and RSI.

Understanding the Strategy

1. SMA Crossover: The Trend Following Signal

The script first calculates two Simple Moving Averages (SMA):

The crossover strategy is simple:

This works because moving averages smooth out price noise, helping identify the overall trend direction.

2. RSI: The Overbought/Oversold Indicator

The Relative Strength Index (RSI) measures whether a stock is overbought or oversold:

By combining SMA crossovers (trend confirmation) and RSI extremes (timing), we get stronger signals.

This plot is generated with less than 40 lines of python code

The code looks like that:

import yfinance as yf import matplotlib.pyplot as plt import seaborn as sns # Get data ticker = “AAPL” df = yf.download(ticker, start=”2024-01-01″, end=”2025-01-01”) sns.set_style(“whitegrid”) # Moving Averages df[‘SMA_20’] = df[‘Close’].rolling(20).mean() df[‘SMA_50’] = df[‘Close’].rolling(50).mean() # RSI Calculation delta = df[‘Close’].diff(1) gain = delta.clip(lower=0) loss = -delta.clip(upper=0) rs = gain.rolling(14).mean() / loss.rolling(14).mean() df[‘RSI’] = 100 – (100 / (1 + rs)) # Signals df[‘Buy’] = (df[‘SMA_20’] > df[‘SMA_50’]) & (df[‘RSI’] < 30) df[‘Sell’] = (df[‘SMA_20’] < df[‘SMA_50’]) & (df[‘RSI’] > 70) # Plot plt.figure(figsize=(12,6)) plt.plot(df[‘Close’], label=”Price”) plt.plot(df[‘SMA_20’], label=”20-day SMA”) plt.plot(df[‘SMA_50’], label=”50-day SMA”) plt.scatter(df.index[df[‘Buy’]], df[‘Close’][df[‘Buy’]], color=”green”, marker=”^”, label=”Buy”) plt.scatter(df.index[df[‘Sell’]], df[‘Close’][df[‘Sell’]], color=”red”, marker=”v”, label=”Sell”) plt.title(f'{ticker} Combined Trading Signals (SMA + RSI)’) plt.legend() plt.show()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

import yfinance as yf

import matplotlib.pyplot as plt

import seaborn as sns

# Get data

ticker = “AAPL”

df = yf.download(ticker, start=“2024-01-01”, end=“2025-01-01”)

sns.set_style(“whitegrid”)

# Moving Averages

df[‘SMA_20’] = df[‘Close’].rolling(20).mean()

df[‘SMA_50’] = df[‘Close’].rolling(50).mean()

# RSI Calculation

delta = df[‘Close’].diff(1)

gain = delta.clip(lower=0)

loss = –delta.clip(upper=0)

rs = gain.rolling(14).mean() / loss.rolling(14).mean()

df[‘RSI’] = 100 – (100 / (1 + rs))

# Signals

df[‘Buy’] = (df[‘SMA_20’] > df[‘SMA_50’]) & (df[‘RSI’] < 30)

df[‘Sell’] = (df[‘SMA_20’] < df[‘SMA_50’]) & (df[‘RSI’] > 70)

# Plot

plt.figure(figsize=(12,6))

plt.plot(df[‘Close’], label=‘Price’)

plt.plot(df[‘SMA_20’], label=’20-day SMA’)

plt.plot(df[‘SMA_50’], label=’50-day SMA’)

plt.scatter(df.index[df[‘Buy’]], df[‘Close’][df[‘Buy’]], color=‘green’, marker=‘^’, label=‘Buy’)

plt.scatter(df.index[df[‘Sell’]], df[‘Close’][df[‘Sell’]], color=‘red’, marker=‘v’, label=‘Sell’)

plt.title(f‘{ticker} Combined Trading Signals (SMA + RSI)’)

plt.legend()

plt.show()

The code above, but in way more details is explained in the YT video below:

https://www.youtube.com/watch?v=m0ayASmrZmE

And it is available in GitHub as well.

Source link

می 3, 2025

نویسنده: AliBina

Why Do These Rules Work?

Exact Formulas?

# Trick 1 – Simple reading of worksheet from Excel workbook

# Trick 2 – Combine Reports

# Trick 3 – Fix Missing Values

# Trick 4 – Formatting the exported Excel file

# Trick 5 – Merging Excel Files

# Trick 6 – Smart Filtering

# Trick 7 – Mergining Tables

# Trick 8 – Export Dataframe to Excel

1. Time-Additivity

2. Symmetry Matters

3. Better for Modeling

When to Use Simple Returns?

Code Highlights

Understanding the Strategy

1. SMA Crossover: The Trend Following Signal

2. RSI: The Overbought/Oversold Indicator