دسته: هسته اصلی سیستم‌عامل

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…

Read more ›

Source link

می 9, 2025
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

Guide for Businesses Navigating Global Data Privacy

Organizations manage personal data across multiple jurisdictions in today’s interconnected digital economy, requiring a clear understanding of global data protection frameworks. The European Union’s General Data Protection Regulation (GDPR) and India’s Digital Personal Data Protection Act (DPDP) 2023 are two key regulations shaping the data privacy landscape. This guide provides a comparative analysis of these regulations, outlining key distinctions for businesses operating across both regions.

Understanding the GDPR: Key Considerations for Businesses

The GDPR, enforced in May 2018, is a comprehensive data protection law that applies to any organization processing personal data of EU residents, regardless of location.

Territorial Scope: GDPR applies to organizations with an establishment in the EU or those that offer goods or services to, or monitor the behavior of, EU residents, requiring many global enterprises to comply.
Definition of Personal Data: The GDPR defines personal data as any information related to an identifiable individual. It further classifies sensitive personal data and imposes stricter processing requirements.
Principles of Processing: Compliance requires adherence to lawfulness, fairness, transparency, purpose limitation, data minimization, accuracy, storage limitation, integrity, confidentiality, and accountability in data processing activities.
Lawful Basis for Processing: Businesses must establish a lawful basis for processing, such as consent, contract, legal obligation, vital interests, public task, or legitimate interest.
Data Subject Rights: GDPR grants individuals rights, including access, rectification, erasure, restriction, data portability, and objection to processing, necessitating dedicated mechanisms to address these requests.
Obligations of Controllers and Processors: GDPR imposes direct responsibilities on data controllers and processors, requiring them to implement security measures, maintain processing records, and adhere to breach notification protocols.

Understanding the DPDP Act 2023: Implications for Businesses in India

The DPDP Act 2023, enacted in August 2023, establishes a legal framework for the processing of digital personal data in India.

Territorial Scope: The Act applies to digital personal data processing in India and processing outside India if it involves offering goods or services to Indian data principals.
Definition of Personal Data: Personal data refers to any data that identifies an individual, specifically in digital form. Unlike GDPR, the Act does not differentiate between general and sensitive personal data (though future classifications may emerge).
Principles of Data Processing: The Act mandates lawful and transparent processing, purpose limitation, data minimization, accuracy, storage limitation, security safeguards, and accountability.
Lawful Basis for Processing: The primary basis for processing is explicit, informed, unconditional, and unambiguous consent, with certain legitimate exceptions.
Rights of Data Principals: Individuals can access, correct, and erase their data, seek grievance redressal, and nominate another person to exercise their rights if they become incapacitated.
Obligations of Data Fiduciaries and Processors: The Act imposes direct responsibilities on Data Fiduciaries (equivalent to GDPR controllers) to obtain consent, ensure data accuracy, implement safeguards, and report breaches. Data Processors (like GDPR processors) operate under contractual obligations set by Data Fiduciaries.

GDPR vs. DPDP: Key Differences for Businesses

Feature	GDPR	DPDP Act 2023	Business Implications
Data Scope	Covers both digital and non-digital personal data within a filing system.	Applies primarily to digital personal data.	Businesses need to assess their data inventory and processing activities, particularly for non-digital data handled in India.
Sensitive Data	Explicitly defines and provides stricter rules for processing sensitive personal data.	Applies a uniform standard to all digital personal data currently.	Organizations should be mindful of potential future classifications of sensitive data under DPDP.
Lawful Basis	Offers multiple lawful bases for processing, including legitimate interests and contractual necessity.	Primarily consent-based, with limited exceptions for legitimate uses.	Businesses need to prioritize obtaining explicit consent for data processing in India and carefully evaluate the scope of legitimate use exceptions.
Individual Rights	Provides a broader range of rights, including data portability and the right to object to profiling.	Focuses on core rights like access, correction, and erasure.	Compliance programs should address the specific set of rights granted under the DPDP Act.
Data Transfer	Strict mechanisms for international data transfers, requiring adequacy decisions or safeguards.	Permits cross-border transfers except to countries specifically restricted by the Indian government.	Businesses need to monitor the list of restricted countries for data transfers from India.
Breach Notification	Requires notification to the supervisory authority if the breach is likely to result in a high risk to individuals.	Mandates notification to both the Data Protection Board and affected Data Principals for all breaches.	Organizations must establish comprehensive data breach response plans aligned with DPDP’s broader notification requirements.
Enforcement	Enforced by Data Protection Authorities in each EU member state.	Enforced by the central Data Protection Board of India.	Businesses need to be aware of the centralized enforcement mechanism under the DPDP Act.
Data Protection Officer (DPO)	Mandatory for certain organizations based on processing activities.	Mandatory for Significant Data Fiduciaries, with criteria to be specified.	Organizations that meet the criteria for Significant Data Fiduciaries under DPDP will need to appoint a DPO.
Data Processor Obligations	Imposes direct obligations on data processors.	Obligations are primarily contractual between Data Fiduciaries and Data Processors.	Data Fiduciaries in India bear greater responsibility for ensuring the compliance of their Data Processors.

Navigating Global Compliance: A Strategic Approach for Businesses

Organizations subject to GDPR and DPDP must implement a harmonized yet region-specific compliance strategy. Key focus areas include:

Data Mapping and Inventory: Identify and categorize personal data flows across jurisdictions to determine applicable regulatory requirements.
Consent Management: Implement mechanisms that align with GDPR’s “freely given, specific, informed, and unambiguous” consent standard and DPDP’s stricter “free, specific, informed, unconditional, and unambiguous” requirement. Ensure easy withdrawal options.
Data Security Measures: Deploy technical and organizational safeguards proportionate to data processing risks, meeting the security mandates of both regulations.
Data Breach Response Plan: Establish incident response protocols that meet GDPR and DPDP notification requirements, particularly DPDP’s broader scope.
Data Subject/Principal Rights Management: Develop workflows to handle data access, correction, and erasure requests under both regulations, ensuring compliance with response timelines.
Cross-Border Data Transfer Mechanisms: Implement safeguards for international data transfers, aligning with GDPR’s standard contractual clauses and DPDP’s yet-to-be-defined jurisdictional rules.
Appointment of DPO/Contact Person: Assess whether a Data Protection Officer (DPO) is required under GDPR or if the organization qualifies as a Significant Data Fiduciary under DPDP, necessitating a DPO or designated contact person.
Employee Training: Conduct training programs on data privacy laws and best practices to maintain team compliance awareness.
Regular Audits: Perform periodic audits to evaluate data protection measures, adapting to evolving regulatory guidelines.

Conclusion: Towards a Global Privacy-Centric Approach

While GDPR and the DPDP Act 2023 share a common goal of enhancing data protection, they differ in scope, consent requirements, and enforcement mechanisms. Businesses operating across multiple jurisdictions must adopt a comprehensive, adaptable compliance strategy that aligns with both regulations.

By strengthening data governance, implementing robust security controls, and fostering a privacy-first culture, organizations can navigate global data protection challenges effectively and build trust with stakeholders.

Seqrite offers cybersecurity and data protection solutions to help businesses achieve and maintain compliance with evolving global privacy regulations.

Source link

می 7, 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…

Read more ›

Source link

می 7, 2025

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()

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

دسته: هسته اصلی سیستم‌عامل

Why Do These Rules Work?

Exact Formulas?

Understanding the GDPR: Key Considerations for Businesses

Understanding the DPDP Act 2023: Implications for Businesses in India

GDPR vs. DPDP: Key Differences for Businesses

Navigating Global Compliance: A Strategic Approach for Businesses

Conclusion: Towards a Global Privacy-Centric Approach

# 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