Position Size = (Account × Risk %) / (Entry Price - Stop Loss Price)

def calculate_position_size_beginner(
    account_size,
    entry_price,
    stop_loss_price,
    risk_percent=0.02
):
    """
    Beginner-friendly position sizing.
    Risk 2% of account per trade.
    """
    # Calculate risk amount in dollars
    risk_dollars = account_size * risk_percent
# Calculate distance between entry and stop
    stop_distance = abs(entry_price - stop_loss_price)
if stop_distance == 0:
        raise ValueError("Entry and stop loss cannot be the same price")
# Calculate number of shares
    position_size = risk_dollars / stop_distance
return {
        'position_size': int(position_size),
        'position_value': position_size * entry_price,
        'risk_dollars': risk_dollars,
        'stop_loss': stop_loss_price,
        'profit_target': entry_price + (stop_distance * 2)  # 2:1 risk/reward
    }
Example usage
result = calculate_position_size_beginner(
    account_size=100000,
    entry_price=50.00,
    stop_loss_price=48.00,
    risk_percent=0.02
)
print(f"Buy {result['position_size']} shares at $50.00")
print(f"Stop loss at ${result['stop_loss']}")
print(f"Risk $2,000 to make $4,000 (2:1 reward/risk)")
print(f"Position value: ${result['position_value']:,.0f}")

import pandas as pd
import numpy as np
def simple_backtest(prices, signals, position_size_pct=0.02):
    """
    Simple backtest with fixed position sizing.
    """
    account = 100000
    trades = []
    equity = [account]
for i in range(len(signals)):
        if signals[i] == 1:  # Buy signal
            entry = prices[i]
            stop = entry * 0.97  # 3% stop loss
            risk_amount = account * position_size_pct
            shares = risk_amount / (entry - stop)
# Assume we exit 5 bars later
            exit_idx = min(i + 5, len(prices) - 1)
            exit = prices[exit_idx]
pnl = (exit - entry) * shares
            account += pnl
trades.append({
                'entry': entry,
                'exit': exit,
                'shares': shares,
                'pnl': pnl,
                'pct_return': pnl / (entry * shares)
            })
equity.append(account)
return pd.DataFrame(trades), account, equity
Generate sample price data
np.random.seed(42)
prices = pd.Series(100 + np.random.randn(250).cumsum())
signals = (np.random.rand(250) > 0.7).astype(int)
Test three position sizes
for risk_pct in [0.02, 0.05, 0.10]:
    trades, final_account, equity = simple_backtest(prices, signals, risk_pct)
if len(trades) > 0:
        win_rate = (trades['pnl'] > 0).sum() / len(trades)
        print(f"\nRisk {risk_pct*100}% per trade:")
        print(f"  Final Account: ${final_account:,.0f}")
        print(f"  Total Trades: {len(trades)}")
        print(f"  Win Rate: {win_rate:.1%}")
        print(f"  Max Drawdown: {(min(equity) - 100000) / 100000:.1%}")

def backtest_with_scaling(prices, signals, base_risk=0.02, max_loss=0.20):
    """
    Backtest with adaptive position sizing.
    Reduce position size if approaching max loss threshold.
    """
    account = 100000
    starting_account = 100000
    equity_curve = [account]
    max_account = account
for i in range(1, len(signals)):
        if signals[i] == 1:
            entry = prices[i]
            stop = entry * 0.97
            risk_amount = account * base_risk
# Adaptive sizing: reduce if in drawdown
            drawdown_pct = (account - max_account) / max_account
            if drawdown_pct < -max_loss:
                # In severe drawdown, reduce position size by 50%
                risk_amount *= 0.5
shares = risk_amount / (entry - stop)
            exit = prices[min(i + 5, len(prices) - 1)]
            pnl = (exit - entry) * shares
            account += pnl
equity_curve.append(account)
            max_account = max(max_account, account)
return account, equity_curve
account_adaptive, equity_adaptive = backtest_with_scaling(prices, signals)
print(f"Adaptive sizing final account: ${account_adaptive:,.0f}")

Shares = (Account × Risk %) / Stop Distance

Shares = Fixed Number (NOT RECOMMENDED)

Position Size = (Account × Risk %) / Stop Distance
Profit Target = Entry + (Stop Distance × Reward Ratio)