Python trong giao dịch – phân tích dữ liệu, tự động hóa và nghiên cứu

Python giúp tổ chức dữ liệu thị trường, phân tích nhật ký và lặp lại phép tính mà không sao chép công thức thủ công. Nó đặc biệt hữu ích khi bảng tính quá nhỏ hoặc khó duy trì. Bài này dẫn từ thiết lập môi trường tới đoạn mã tải dữ liệu, kiểm tra chất lượng và lưu kết quả. Đồng thời giải thích nghiên cứu trong notebook khác phần mềm kết nối tài khoản giao dịch ra sao và việc tích hợp cần những biện pháp bảo vệ nào.

1. Python hữu ích ở đâu, và ở đâu chỉ có vẻ là giải pháp

Bảng tính xử lý được nhật ký giao dịch chừng nào còn nằm trong giới hạn kiên nhẫn của bạn — ranh giới đó tùy máy, số công thức và cấu trúc bảng, nên không thể mô tả bằng một số giao dịch tròn trịa. Tuy nhiên, có một giới hạn cứng, không phụ thuộc gì khác vì được ghi trong đặc tả định dạng: mỗi trang tính Excel chứa 1.048.576 dòng và 16.384 cột ^[16]. Một năm dữ liệu tick của một cặp tiền đã lớn gấp nhiều lần — không thủ thuật nào vượt được giới hạn ấy.

Python không phải phép màu. Nó giải quyết bốn vấn đề cụ thể mà bảng tính không giải quyết được, hoặc phải tốn hàng giờ:

• Quy mô dữ liệu – giới hạn bởi bộ nhớ máy và định dạng lưu trữ, không bởi số dòng của trang tính
• Khả năng lặp lại – cùng mã chạy ngày mai trên cùng dữ liệu cho cùng kết quả. Bảng tính kéo công thức thủ công không bảo đảm điều đó
• Đổi khoảng thời gian không cần làm thủ công – tổng hợp M1 thành H4 mà giữ OHLCV chỉ là một lần gọi resample, không phải một cột công thức phụ
• Tự động lấy và làm sạch dữ liệu – tập lệnh theo lịch tải, kiểm tra và lưu dữ liệu khi bạn không có mặt

Chỉ vậy thôi. Python không tạo lợi thế thị trường, không nâng chất lượng chiến lược và không đổi điều kiện thực thi tại nhà môi giới. Nó rút ngắn khoảng cách giữa câu hỏi và câu trả lời — chính vì thế, nó cho bạn thấy ý tưởng không hiệu quả nhanh hơn.

Python không làm được gì. Nó không phù hợp giao dịch có độ trễ cực thấp — ở đó từng micro giây đều quan trọng, và ngôn ngữ thông dịch có bộ thu gom bộ nhớ là lựa chọn kém. Nhưng câu “Python quá chậm để giao dịch” cũng sai: với chiến lược vào đầu nến H1 tiếp theo, thời gian tính Python không đáng kể so với thời gian lệnh đi qua mạng và máy chủ nhà môi giới.

Tăng tốc nhờ vector hóa có cơ chế cụ thể: thao tác cả cột chạy trong mã numpy đã biên dịch thay vì vòng lặp thông dịch. Mức chênh lệch tùy dữ liệu, loại thao tác và phần cứng — muốn nêu con số cụ thể, hãy đo trên máy mình bằng mô-đun timeit của thư viện chuẩn ^[4] và ghi kèm phiên bản thư viện. Dẫn chuẩn đo hiệu năng của người khác mà thiếu môi trường không phải phép đo.

So sánh công cụ phân tích của người giao dịch:

Phân biệt ở dòng cuối quan trọng hơn vẻ ngoài. Pine Script chạy trong TradingView, MQL trong phần mềm MetaTrader, còn Python ở bất cứ nơi nào bạn chạy nó. Sự tự do ấy có nghĩa bạn chịu trách nhiệm về môi trường: phiên bản thư viện, múi giờ hệ thống, thời gian hoạt động và cả việc mã có được phép tác động tài khoản hay không.

2. Môi trường tái lập: phiên bản, venv, requirements

Nguyên nhân rất thường gặp khiến mã của người khác “không chạy” không nằm trong mã. Tác giả đã chạy bằng phiên bản thư viện khác và không ghi lại. Trong phân tích dữ liệu thị trường, đây không chỉ là bất tiện — nó làm kết quả mất giá trị vì không thể tái lập.

Môi trường tái lập khi nêu được sáu điều: phiên bản Python, phương pháp cô lập, phiên bản phụ thuộc cố định, nguồn dữ liệu và khoảng ngày, múi giờ, cùng hạt giống ngẫu nhiên ở mọi nơi kết quả phụ thuộc ngẫu nhiên. Thiếu một yếu tố, kết quả là câu chuyện chứ không phải phép đo.

Môi trường ảo là bắt buộc. Cài thư viện “toàn cục” khiến cập nhật dự án này có thể làm hỏng dự án khác. Cô lập không tốn phí, chỉ mất khoảng chục giây và dựa vào mô-đun venv của thư viện chuẩn ^[4]:

# Windows, PowerShell
py -3.12 -m venv .venv
.venv\Scripts\Activate.ps1

# macOS / Linux
python3.12 -m venv .venv
source .venv/bin/activate

# dùng chung cho hai hệ thống
python -m pip install --upgrade pip
python -m pip install pandas numpy matplotlib requests python-dotenv
python -m pip freeze > requirements.txt

Dòng cuối thường bị bỏ qua nhất. pip freeze ghi lại chính xác phiên bản mọi thứ thực sự đã cài — kể cả phụ thuộc bạn không biết tới. Đưa tệp đó vào kho cạnh mã. Khi ấy tái tạo môi trường trên máy khác là python -m pip install -r requirements.txt, không phải đoán.

Môi trường dùng cho lần kiểm tra ngoại tuyến hiện tại của các ví dụ tính toán phần 4 và 9: Windows 11, Python 3.12.10, pandas 3.0.5 và NumPy 2.5.3, kiểm tra ngày 8 tháng 10 năm 2026. Danh sách dưới ghi các gói liên quan những phép tính ấy; đây là danh mục giới hạn, không phải bản xuất mọi gói cài trên máy^[1][3].

# Phiên bản phụ thuộc dùng để xác minh tính toán cục bộ
numpy==2.5.3
pandas==3.0.5
python-dateutil==2.9.0.post0
six==1.17.0
tzdata==2026.4

# trình thông dịch
Python 3.12.10

Lưu ý pandas còn dùng các gói khác: mô tả môi trường không dừng ở một phiên bản thư viện. Phụ thuộc có thể gây khác biệt giữa các máy. Các lệnh cài ở trên minh họa quy trình thiết lập dự án; không phải hồ sơ cài đặt đã thực hiện trong lần kiểm tra này. Hãy tạo tệp requirements.txt đầy đủ trong chính môi trường của bạn bằng python -m pip freeze và giữ cùng mã.

Tệp này cũng không mô tả toàn bộ môi trường cho cả bài, mà chỉ cho các phần tính toán. Đoạn kiểm tra xử lý lỗi HTTP ở phần 7 đã chạy trong môi trường bổ sung requests 2.34.2, còn kiểm tra cổng an toàn ở phần 8 không cần gói ngoài thư viện chuẩn. Không nêu phiên bản matplotlib và python-dotenv vì chúng không được dùng trong ví dụ nào thực sự chạy — liệt kê “cho đầy đủ” sẽ thành ghi con số chưa ai kiểm tra. Nếu dựng môi trường cho toàn bộ nội dung, hãy coi lệnh cài ở trên là điểm khởi đầu và cố định pip freeze của riêng bạn; chỉ tệp phụ thuộc ấy mới nói được điều gì về kết quả của bạn.

Notebook hay tệp .py? Cả hai, nhưng cho việc khác nhau. Jupyter hữu ích khi chưa biết đang tìm gì: chạy một ô, xem kết quả, đổi tham số. Tuy nhiên, một đặc tính khiến nó không phù hợp làm nơi chứa mã thực thi: trạng thái biến phụ thuộc thứ tự chạy ô, không phụ thuộc thứ tự ô trong tệp. Notebook chạy theo thứ tự 1–3–2 trông giống hệt notebook chạy tuần tự. Mã tác động tài khoản phải nằm trong tệp .py thông thường, chạy từ trên xuống, có kiểm thử và nhật ký.

Anaconda và Google Colab là lối tắt có chi phí riêng. Anaconda cài nhiều gói một lúc và có trình quản lý phụ thuộc riêng, giúp bắt đầu dễ hơn nhưng khó mô tả chính xác môi trường khi trộn conda với pip. Colab chạy trong trình duyệt không cần cài, phù hợp để học, nhưng mỗi phiên lại tạo môi trường từ đầu và phiên bản thư viện thay đổi ngoài sự kiểm soát của bạn. Với tài liệu cần tái lập sau một năm, cả hai đều đòi hỏi thêm kỷ luật.

Thư viện để bắt đầu – bốn mục, không phải bốn mươi (có năm gói vì mục đầu là một cặp):

• pandas và numpy – cấu trúc dữ liệu và tính toán
• matplotlib – biểu đồ
• requests – giao tiếp HTTP với API
• python-dotenv – tải cấu hình từ tệp ngoài kho mã

Chỉ thêm chỉ báo kỹ thuật khi thực sự cần. Một điểm cần sửa so với hướng dẫn cũ: TA-Lib phát hành gói nhị phân wheel chính thức kèm thư viện C trên PyPI; vì thế với tổ hợp hệ điều hành, kiến trúc và Python được hỗ trợ, lệnh pip install TA-Lib không cần tải bản không chính thức hay tự biên dịch^[9]. Kiểm tra wheel cụ thể trước khi cài; đây không phải lời hứa chạy trên mọi máy. Siêu dữ liệu kiểm tra ngày 8 tháng 10 năm 2026 ghi TA-Lib 0.8.1 và pandas-ta vẫn ở 0.4.71b0, phát hành tháng 9 năm 2025^[13]. Gói sau cố định numba==0.61.2, nên chỉ kiểm tra yêu cầu pandas là chưa đủ. Kiểm tra cài đặt lịch sử trên Python 3.14.3, ngày 22 tháng 8 năm 2026, thất bại tại phụ thuộc đó với thông báo only versions >=3.10,<3.14 are supported. Quan sát ấy không tự động áp dụng cho ví dụ hiện tại chạy Python 3.12.10. Lần kiểm tra hiện tại đọc siêu dữ liệu PyPI; không cài hay chạy TA-Lib hoặc pandas-ta. Vì thế quy tắc kiểm tra bên cạnh còn quá hẹp: phát hành gần đây và yêu cầu pandas tương thích không chứng minh toàn bộ phụ thuộc cài được và chạy đúng. Cũng phải kiểm tra thư viện biên dịch bị cố định, wheel cho trình thông dịch và phép thử với dữ liệu nhỏ. Siêu dữ liệu hai bản mới nhất không mô tả toàn bộ lịch sử dự án; hãy đánh giá các khoảng ngừng trước đó trong kho mã.

Hạt giống ngẫu nhiên. Ở mọi nơi kết quả phụ thuộc ngẫu nhiên — chia mẫu, bootstrap, mô phỏng, khởi tạo mô hình — phải đặt và ghi hạt giống. Trong numpy: rng = np.random.default_rng(20260822) ^[3], rồi chỉ dùng đối tượng ấy. Thiếu nó, hai lần chạy cùng mã cho hai kết quả khác nhau và không rõ bạn đang mô tả kết quả nào.

3. pandas và numpy: dữ liệu OHLCV, chỉ số thời gian, múi giờ

numpy xử lý tính toán trên mảng số, pandas xử lý cấu trúc: DataFrame là bảng có tên cột và chỉ số, thường là chỉ số thời gian. Với dữ liệu thị trường, chỉ số thời gian quan trọng hơn phép tính, vì nó quyết định bạn có thực sự tính đúng điều mình nghĩ hay không.

Tải dữ liệu – pd.read_csv() xử lý được tệp hàng triệu dòng, nhận biết dấu phân cách và tự phân tích ngày khi chỉ rõ cột. Tuy nhiên, mặc định nó không biết múi giờ; đó là điều đầu tiên phải xác lập.

Đổi khoảng thời gian – tổng hợp M1 thành H4 mà giữ OHLCV chỉ cần một lần gọi: df.resample('4h').agg({'open':'first', 'high':'max', 'low':'min', 'close':'last', 'tick_volume':'sum'}). Chú ý hai đối số thường bị bỏ qua nhưng quyết định cách diễn giải: label quyết định gắn nhãn đầu hay cuối cửa sổ, còn closed quyết định mép khoảng nào thuộc cửa sổ. Với phần lớn tần suất, mặc định gắn nhãn tại mép trái ^[1], tức dấu thời gian nến là lúc mở; trong pandas 3.0.5, resample('4h') trên tám nến giờ từ nửa đêm cho nhãn 00:00 và 04:00. Nếu quy ước tín hiệu giả định lúc đóng nhưng dữ liệu gắn nhãn lúc mở, bạn vô tình dịch toàn bộ kết quả một khoảng.

Thống kê trượt – df['close'].rolling(20).mean() cho trung bình động, .rolling(20).std() cho độ lệch dùng trong Dải Bollinger, .ewm(span=20).mean() cho trung bình hàm mũ ^[1]. Tất cả chỉ tính từ dữ liệu quá khứ so với dòng hiện tại — tính chất ấy là nền tảng cho tính đúng đắn của mọi bước còn lại.

Lọc dữ liệu – điều kiện kết hợp chỉ cần viết một lần: df[(df['sma20'] > df['sma50']) & (df['rsi'] < 30)]. Bắt buộc đặt ngoặc quanh từng điều kiện, vì & có độ ưu tiên cao hơn phép so sánh trong Python — bỏ ngoặc gây lỗi thay vì âm thầm cho đáp án sai; ở điểm này, đó là điều có lợi.

Múi giờ là quyết định, không phải chi tiết. Dữ liệu nhà môi giới thường mang dấu thời gian máy chủ, nguồn ngoài thường dùng UTC, còn hệ điều hành có thể dùng giờ địa phương với quy tắc đổi giờ của vùng đã chọn. Trộn ba đồng hồ này sẽ khiến phân tích “phiên London” nghiên cứu thứ khác với phiên London.

Quy tắc thực hành là xác định múi giờ nguồn trước, rồi tính bằng UTC. Với dấu thời gian có độ lệch rõ ràng hoặc Z, dùng pd.to_datetime(column, utc=True). Với thời gian máy chủ không có độ lệch, trước hết phân tích rồi gán múi giờ đã xác nhận bằng tz_localize(), xử lý các giờ nhập nhằng hoặc không tồn tại, sau đó dùng tz_convert("UTC"). Chỉ dùng utc=True sẽ coi giá trị không có múi giờ là UTC, không suy ra múi giờ nhà môi giới. Chỉ đổi sang Europe/London khi trình bày^[1]. Chỉ số có múi giờ rõ ràng và nguồn dữ liệu được ghi lại giúp kết hợp các chuỗi nhất quán.

Dữ liệu thiếu. Lịch sử OHLCV có khoảng trống: cuối tuần, ngày lễ, nghỉ kỹ thuật, công cụ không báo giá. pandas cung cấp df.ffill(), điền khoảng trống bằng giá trị cuối đã biết — với dữ liệu giá, đó thường là ý tưởng tệ, vì tạo nến không biến động và làm giảm độ lệch chuẩn. Tốt hơn nên loại các kỳ thiếu và đếm số lượng.

Nhiều công cụ cùng lúc. Để phân tích danh mục tiền tệ, pandas có chỉ số phân cấp MultiIndex: một DataFrame chứa nhiều cặp, đánh chỉ số theo cặp và thời gian. Có thể tính tương quan trên trục thời gian chung, với điều kiện đã đưa mọi chuỗi về cùng múi giờ và cùng lưới thời gian. Nếu không, bạn đang tính tương quan giữa các dữ liệu lệch nhau.

Lưu kết quả. df.to_csv() dễ đọc và phổ dụng. df.to_parquet() tạo tệp nhỏ hơn, đọc nhanh hơn, đồng thời giữ kiểu cột và múi giờ chỉ số ^[1] – CSV ghi mọi thứ dưới dạng văn bản nên phải phân tích lại khi tải. Với dữ liệu làm việc lớn, Parquet thuận tiện hơn nhưng cần bộ ghi bổ sung, vì vậy hãy thêm vào requirements.txt.

4. Ví dụ tối thiểu: CSV → UTC → lợi nhuận → kiểm tra khoảng trống → lưu

Tập lệnh đầu tiên không nên gửi lệnh hay thậm chí kết nối nhà môi giới. Nó nên làm việc hữu ích, kiểm tra được và hoàn toàn an toàn: tải tệp, xử lý thời gian, tính lợi nhuận, nói rõ dữ liệu có lỗi gì và lưu kết quả.

Giả định. Tệp CSV có các cột time,open,high,low,close,tick_volume. Cột time ở định dạng ISO 8601 kèm dấu múi giờ (Z nghĩa là UTC). Khoảng thời gian được khai báo là một giờ. Tệp chạy được cố ý cài ba lỗi thường có trong dữ liệu xuất: một dấu thời gian trùng, một giờ thiếu và một ô khối lượng trống. Sáu dòng được dán trực tiếp vào mã để bạn chạy và nhận đúng cùng kết quả mà không tải tệp — kết quả không thể tái lập không phải kết quả. Môi trường: Python 3.12.10, pandas 3.0.5, numpy 2.5.3, Windows 11, [CẬP NHẬT: 2026-10-08].

"""Ví dụ tối thiểu: CSV -> UTC -> lợi suất log -> kiểm tra khoảng trống -> lưu."""
import io
from pathlib import Path

import numpy as np
import pandas as pd

# Dữ liệu đặt ngay trong mã để tái tạo kết quả mà không tải tệp.
# Sáu hàng với ba lỗi có chủ đích: trùng dấu thời gian 01:00,
# thiếu giờ 03:00 và ô khối lượng trống lúc 02:00.
CSV_DATA = """time,open,high,low,close,tick_volume
2026-06-01T00:00:00Z,1.08140,1.08170,1.08131,1.08153,812
2026-06-01T01:00:00Z,1.08153,1.08190,1.08150,1.08176,640
2026-06-01T01:00:00Z,1.08153,1.08195,1.08149,1.08182,655
2026-06-01T02:00:00Z,1.08182,1.08188,1.08130,1.08141,
2026-06-01T04:00:00Z,1.08120,1.08125,1.08040,1.08050,903
2026-06-01T05:00:00Z,1.08050,1.08061,1.07980,1.07993,774
"""

OUTPUT = Path("EURUSD_H1_returns.csv")
INTERVAL = "1h"  # tần suất khai báo của dữ liệu đầu vào


def load_data(source) -> pd.DataFrame:
    """Nạp CSV và đặt chỉ mục có múi giờ theo UTC.

    Cố ý không sắp xếp: thứ tự hàng trong tệp cũng là thông tin
    về chất lượng xuất dữ liệu. Chỉ sắp xếp sau khi lập báo cáo.
    """
    df = pd.read_csv(source)
    # utc=True buộc dùng một múi giờ; thiếu nó pandas có thể trả chỉ mục không có múi giờ
    df["time"] = pd.to_datetime(df["time"], utc=True, format="ISO8601")
    return df.set_index("time")


def quality_report(df: pd.DataFrame, interval: str) -> dict:
    """Các bộ đếm cần xem trước khi tính bất kỳ giá trị nào."""
    expected = pd.date_range(df.index.min(), df.index.max(), freq=interval, tz="UTC")
    return {
        "rows": int(len(df)),
        "index_duplicates": int(df.index.duplicated().sum()),
        "missing_cells": int(df.isna().sum().sum()),
        "missing_timestamps": int(len(expected.difference(df.index))),
        # Đo TRƯỚC khi sắp xếp: sau sort_index() kiểm tra này luôn
        # đúng và không bao giờ phát hiện tệp có thứ tự thời gian xáo trộn.
        "file_chronology_ok": bool(df.index.is_monotonic_increasing),
    }


def add_returns(df: pd.DataFrame) -> pd.DataFrame:
    """Lợi suất log = ln(close_t / close_(t-1)). Đơn vị: logarit tự nhiên, không thứ nguyên."""
    df = df[~df.index.duplicated(keep="last")].copy()
    df["log_return"] = np.log(df["close"]).diff()
    return df


def main() -> None:
    df = load_data(io.StringIO(CSV_DATA))  # trong thực tế: load_data(Path("EURUSD_H1.csv"))
    print("kiểm tra chất lượng:", quality_report(df, INTERVAL))
    df = add_returns(df.sort_index())
    print("số nến sau loại trùng:", len(df))
    print("tổng lợi suất log:", round(float(df["log_return"].sum()), 6))
    print("độ lệch chuẩn lợi suất log (khoảng 1h và 2h):",
          round(float(df["log_return"].std()), 6))
    df.to_csv(OUTPUT)
    print("đã lưu:", OUTPUT)


if __name__ == "__main__":
    main()

Đầu ra của lần chạy trên dữ liệu dán trong mã và môi trường đã mô tả — bạn có thể tái lập chính xác:

kiểm tra chất lượng: {'rows': 6, 'index_duplicates': 1, 'missing_cells': 1, 'missing_timestamps': 1, 'file_chronology_ok': True}
số nến sau loại trùng: 5
tổng lợi suất log: -0.00148
độ lệch chuẩn lợi suất log (khoảng 1h và 2h): 0.000467
đã lưu: EURUSD_H1_returns.csv

Diễn giải. Mã phát hiện đủ ba lỗi được cài trước khi tính bất cứ gì — đó là toàn bộ giá trị của nó. Tổng lợi nhuận log là −0,00148; còn năm nến sau loại trùng, tức bốn khoảng giữa các giá quan sát liên tiếp, tương ứng tỷ giá giảm khoảng 0,15 phần trăm trong cửa sổ nghiên cứu. Sáu là số dòng tệp, không phải số nến: một dòng bị trùng. Độ lệch chuẩn 0,000467 là đại lượng cho từng nến H1, không phải theo năm hay ngày; so sánh mà không nêu khoảng thời gian là vô nghĩa. Lợi nhuận log không có đơn vị và cộng được theo thời gian — vì thế cộng chứ không nhân như lợi nhuận đơn.

Giới hạn. Năm nến chỉ minh họa cơ chế, không phải mẫu thống kê — không thể kết luận gì về thị trường từ số quan sát ấy. Mã không mô hình hóa spread, hoa hồng hay trượt giá, vì đây không phải backtest; nó tính lợi nhuận giá, không phải kết quả tài khoản. Phát hiện dấu thời gian thiếu giả định dữ liệu đúng tần suất giờ khai báo — nếu qua cuối tuần, nhiều dấu “thiếu” là bình thường, nên phải đặt ngưỡng cảnh báo theo lịch giao dịch. Một bẫy riêng nằm ở thước đo: mã phát hiện khoảng trống nhưng không điền, nên lợi nhuận bắc qua giờ thiếu bao phủ hai khoảng, không phải một. Trong ví dụ, đó là một trong bốn lợi nhuận, dù cả tập vẫn được gọi là đại lượng “mỗi nến H1” — đây là giản lược, không phải đo chính xác. Cách trung thực có hai hướng: đặt lại chỉ số theo lưới đủ từng giờ và giữ giá trị trống tại khoảng thiếu, hoặc công bố việc trộn thời hạn như giới hạn của phép đo.

Vì sao kiểm tra thứ tự thời gian trước khi sắp xếp. Nếu load_data() kết thúc bằng lần gọi sort_index(), thì kết quả file_chronology_ok sẽ luôn đúng — kiểm tra quảng bá trong báo cáo không thể phát hiện gì, và tệp sai thứ tự sẽ vượt qua mà không để dấu. Kiểm tra không thể thất bại còn tệ hơn không kiểm tra vì tạo cảm giác đã xác thực. Vì thế phải đo thứ tự trên dữ liệu vừa tải từ tệp, chỉ sắp xếp sau khi lập báo cáo.

Tình trạng xác minh: đoạn này đã chạy trong môi trường nêu trên, đầu ra phía trên là đầu ra thật của chương trình. Ở phiên bản pandas khác, định dạng từ điển hoặc cách làm tròn có thể khác.

5. Trực quan hóa: mỗi biểu đồ một câu hỏi

Một con số tóm tắt che giấu điều quan trọng nhất: khi nào chiến lược lỗ, kéo dài bao lâu, và toàn bộ kết quả có dựa vào ba giao dịch không. Biểu đồ không phải vật trang trí báo cáo — nó đặt câu hỏi với dữ liệu mà bảng không trả lời.

matplotlib là thư viện biểu đồ cơ bản của Python: tĩnh và cú pháp khá vụng. plotly cho biểu đồ tương tác — rê vào điểm để xem ngày và giá trị, phóng to một đoạn, xuất HTML. Với tập rất lớn, nó có thể chậm hơn và cần cài riêng. Để khám phá trong notebook, plotly tiện hơn; để lưu biểu đồ vào báo cáo, dùng matplotlib.

Bốn biểu đồ nên biết vẽ vì mỗi loại trả lời một câu hỏi:

1. Đường vốn – kết quả lũy kế theo thời gian. Trả lời “có tăng và tăng khi nào”, không trả lời “tôi sẽ kiếm bao nhiêu”
2. Biểu đồ sụt giảm vốn – khoảng cách với đỉnh lũy kế tại từng thời điểm. Thể hiện sụt giảm sâu nhất và thời gian phục hồi. Luôn ghi rõ tính trên số dư hay vốn chủ sở hữu tức thời, bằng phần trăm hay bằng tiền
3. Bản đồ nhiệt theo phiên – kết quả chia theo giờ và thứ trong tuần. Phải giải quyết múi giờ trước, nếu không nó mô tả những giờ không tồn tại
4. Phân bố lợi nhuận – biểu đồ tần suất kết quả từng giao dịch. Thể hiện đuôi dày và bất đối xứng mà một chỉ số rủi ro không cho thấy

Để vẽ nến trực tiếp từ DataFrame có mplfinance, lớp trên matplotlib — kèm lưu ý từ quy tắc phần 2: bản phát hành gần nhất có từ tháng 8 năm 2023 và vẫn mang số phiên bản tiền phát hành (0.12.10b0) ^[13] [CẬP NHẬT: 2026-10-08]. Điều ấy không tự động loại nó, nhưng trước khi thêm vào requirements.txt, hãy thử trên dữ liệu mình xem có chạy với phiên bản matplotlib và pandas đang dùng không — bản phát hành mới không kiểm tra thay bạn. Muốn biến tập lệnh thành bảng điều khiển đơn giản có thanh trượt và danh sách chọn, có streamlit, dự án được phát hành đều đặn ^[13], khởi chạy bằng streamlit run dashboard.py. Cả hai tiết kiệm thời gian và đều thêm phụ thuộc vào requirements.txt, nên hãy thêm có chủ ý.

Quy tắc thực hành: nếu không thể nói bằng một câu biểu đồ trả lời câu hỏi nào, bạn không cần nó. Biểu đồ không có câu hỏi là trang trí; trang trí trong phân tích kết quả có thể đắt giá vì gợi kết luận dữ liệu không chứa.

6. Backtest bằng Python: phần thuộc mã và phần thuộc phương pháp

Đây là ranh giới dễ bỏ qua. Python chịu trách nhiệm triển khai bài kiểm thử: tải dữ liệu, tính tín hiệu, gán kết quả đúng kỳ, tính chi phí và thước đo. Nó không chịu trách nhiệm phương pháp: chia mẫu, số biến thể đã thử, mô hình thực thi, đánh giá độ vững của kết quả. Phương pháp là chủ đề bài riêng — Tài khoản demo, backtest và kiểm thử tiến — không thư viện tốt hơn nào thay thế được.

Chỉ có pandas chưa phải backtest. Nhân cột tín hiệu với cột lợi nhuận tạo chuỗi kết quả, nhưng không mô hình hóa điều xảy ra giữa quyết định và thực thi: thời điểm vào, giá vào, spread, hoa hồng, swap, khớp một phần hay từ chối lệnh. Đây có thể là giản lược chấp nhận được khi sàng ý tưởng — miễn gọi đúng là giản lược, không gọi là kết quả.

Nếu muốn đi xa hơn vòng lặp tự viết, hệ sinh thái Python có ba hướng công cụ sẵn. Bảng so sánh theo cách hoạt động, không theo lời hứa hiệu năng — thời gian cụ thể tùy dữ liệu, phần cứng và phiên bản, nên nếu cần hãy tự đo và ghi môi trường.

Dòng cuối không phải thủ tục. Mỗi framework giả định một mức giá và thời điểm khớp — chính giả định đó, không phải logic chiến lược, thường quyết định kết quả. Trước khi tin thư viện, tìm trong tài liệu ba câu trả lời: khớp điểm vào ở giá nào, tính chi phí ra sao, xử lý khoảng nhảy giá giữa các nến thế nào.

Tự do của mã đồng thời là rủi ro. Bộ kiểm thử tích hợp áp đặt một số quy tắc nên bảo vệ bạn khỏi một số lỗi. Mã tự viết không bảo vệ gì: nó không hỏi đã tách dữ liệu huấn luyện và xác thực chưa, không nhận ra tín hiệu dùng giá chưa tồn tại lúc đó, không đếm số biến thể đã thử. Toàn bộ trách nhiệm chuyển sang tác giả — vì thế các phần sau xét những thứ có thể hỏng âm thầm trong mã.

7. API nhà môi giới: xác thực, giới hạn, lỗi, môi trường thử nghiệm

Câu “nhà môi giới cung cấp API” đôi khi bị hiểu thành “tôi có quyền truy cập tài khoản không giới hạn bằng mã”. Thực tế khác: API là tập điểm cuối có xác thực, quyền hạn, giới hạn tần suất và tập mã lỗi xác định. Đôi khi, nhưng không phải luôn, nó tách môi trường thử nghiệm và sản xuất; cách tách phải đọc tài liệu, không được mặc định. Trước dòng mã đầu tiên, cần trả lời chín câu hỏi: xác thực ra sao, token có quyền gì, được gửi bao nhiêu yêu cầu mỗi giây, phân biệt thử nghiệm và sản xuất thế nào, trả về loại dữ liệu nào, định nghĩa mã lỗi nào, có hạn chế vùng không, chính sách duy trì kết nối ra sao, và token có quyền đặt lệnh hay không.

Giới hạn cụ thể và được công bố — nhưng phải đọc đó là giới hạn nào. Phân biệt thường mất trong hướng dẫn này quyết định cách thiết kế vòng lặp. Với OANDA v20, hai con số nằm ở hai tài liệu và có nghĩa khác nhau. Hướng dẫn nhà phát triển nêu mức được cưỡng chế: “120 yêu cầu mỗi giây. Vượt mức sẽ nhận HTTP 429” cho REST API, cùng giới hạn hai mươi luồng đang hoạt động và hai kết nối mới mỗi giây — đều tính theo địa chỉ IP gửi yêu cầu ^[15]. Ngược lại, tài liệu thực hành tốt nêu khuyến nghị: nhà cung cấp khuyên không quá một trăm yêu cầu mỗi giây trên kết nối đã thiết lập và hai kết nối mới mỗi giây ^[5]. [CẬP NHẬT: 2026-08-22]

Vậy một trăm mỗi giây là mức nhà cung cấp khuyên ở dưới, còn một trăm hai mươi là ngưỡng máy chủ trả lỗi 429. Mã giả định “100/s là tối đa” không gây hại, nhưng mã coi đó là giới hạn cứng rồi không xử lý 429 sẽ ngã ngay khi vượt — vì mức cưỡng chế nằm khác mức khuyến nghị. Đây là số của một nhà cung cấp, không phải quy luật thị trường; tại nhà môi giới khác chúng sẽ khác và [TÍNH NĂNG TÙY NHÀ MÔI GIỚI/TÀI KHOẢN]. Hãy kiểm tra tài liệu nhà cung cấp của mình trước khi viết vòng lặp hỏi dữ liệu.

Môi trường thử nghiệm là máy chủ khác, không phải chế độ khác. Ở OANDA, sự tách biệt hiện ngay trong địa chỉ: api-fxpractice.oanda.com cho môi trường thực hành và api-fxtrade.oanda.com cho sản xuất, với cặp địa chỉ tương tự cho luồng dữ liệu ^[15] [CẬP NHẬT: 2026-08-22]. Đây là điều tốt vì có thể chặn nhầm lẫn trong mã: thêm điều kiện bảo vệ máy chủ sản xuất. Khó hơn khi nhà cung cấp dùng chung địa chỉ, chỉ phân biệt bằng token — khi ấy cấu hình là rào chắn duy nhất.

Bốn đường kết nối Python với tài khoản thường gặp — khác kiến trúc, không phải khác mức “cao cấp”:

Ngoài thị trường tiền tệ cũng nên biết ccxt — thư viện thống nhất truy cập các sàn tiền mã hóa. Nó không dùng cho tài khoản FX/CFD ở nhà môi giới cá nhân nhưng đôi khi bị nhầm là giải pháp phổ dụng.

cTrader. Nếu dùng cTrader, thuật toán được viết trong môi trường cTrader Algo, hỗ trợ sẵn cả C# và Python — gồm cBot, chỉ báo và plugin ^[8] [CẬP NHẬT: 2026-08-22]. Đây là mô hình khác các cách trên: mã chạy bên trong nền tảng, không phải tiến trình riêng kết nối API. Kiểm tra phạm vi hàm và cách khởi chạy trong tài liệu hiện hành vì sản phẩm đang phát triển tích cực.

Khóa và mật khẩu: không bao giờ đặt trong mã

Khóa API gõ vào mã sẽ theo nó vào kho, bản sao lưu và lịch sử phiên bản — không biến mất khỏi lịch sử Git khi chỉ xóa dòng. Kho công khai bị quét tự động để tìm chuỗi như vậy. Bí mật chỉ nên ở biến môi trường, tệp cấu hình ngoài kho được liệt kê trong .gitignore, hoặc trình quản lý bí mật cung cấp giá trị qua một trong các cách đó.

"""Cấu hình và bí mật: không đặt thông tin nhạy cảm trong tệp mã."""
import os
from dataclasses import dataclass

HOSTS = {
    "practice": "https://api-fxpractice.oanda.com",
    "live": "https://api-fxtrade.oanda.com",
}


class MissingConfiguration(RuntimeError):
    """Phát sinh khi thiếu dữ liệu bắt buộc để được khởi chạy."""


@dataclass(frozen=True)
class Configuration:
    token: str
    account: str
    environment: str

    @property
    def host(self) -> str:
        return HOSTS[self.environment]


def _required(name: str) -> str:
    value = os.environ.get(name, "").strip()
    if not value:
        # Cố ý không có giá trị mặc định: token trống sẽ khiến yêu cầu được gửi
        # mà không xác thực thay vì dừng chương trình.
        raise MissingConfiguration(f"Thiếu biến môi trường {name}")
    return value


def load_config() -> Configuration:
    environment = os.environ.get("BROKER_ENV", "practice").strip().lower()
    if environment not in HOSTS:
        raise MissingConfiguration(f"BROKER_ENV phải thuộc {sorted(HOSTS)}")
    return Configuration(
        token=_required("BROKER_API_TOKEN"),
        account=_required("BROKER_ACCOUNT_ID"),
        environment=environment,
    )

Ba quyết định trong đoạn này là có chủ ý. Môi trường mặc định là thực hành, không phải sản xuất — lỗi cấu hình khi ấy dẫn tới demo thay vì tài khoản thật. Thiếu biến môi trường sẽ dừng chương trình thay vì thay bằng chuỗi rỗng. Token không có giá trị mặc định ở đâu, kể cả trong chú thích, vì bí mật trong chú thích vẫn là bí mật đã lộ.

Thư viện python-dotenv đã nêu không thay mã này — nó chạy trước. Gọi load_dotenv() (sau from dotenv import load_dotenv) sẽ tải tệp .env ngoài kho vào biến môi trường của tiến trình; sau đó load_config() mới đọc. Nhờ vậy hàm cấu hình không biết và không cần biết giá trị đến từ tệp, thiết lập hệ thống hay trình quản lý bí mật. Chính tệp .env được đưa vào .gitignore cùng toàn bộ thư mục cấu hình.

Lấy dữ liệu: thời hạn chờ, thử lại, mã phản hồi

Yêu cầu không giới hạn thời gian có thể treo vô hạn và đóng băng cả tiến trình. Thử lại vô hạn có thể cạn hạn mức và bị ngắt. Đoạn dưới là bộ bảo vệ tối thiểu khi đọc dữ liệu — kèm phân biệt quan trọng để bảo vệ tài khoản về sau: chỉ thử lại thao tác lũy đẳng, tức lặp lại không làm đổi trạng thái phía nhà môi giới.

import logging
import time

import requests

TIMEOUT_S = 10.0        # số giây chờ không hoạt động khi kết nối/đọc, không phải hạn toàn tác vụ
MAX_ATTEMPTS = 4            # số lần thử tính cả lần đầu
BACKOFF_S = 1.0         # cơ số thời gian chờ tăng theo hàm mũ, tính bằng giây

log = logging.getLogger("data")


class ApiError(RuntimeError):
    """Lỗi không thể sửa bằng cách thử lại."""


def fetch_candles(session: requests.Session, host: str, token: str,
                   instrument: str, parameters: dict) -> dict:
    """Chỉ thử lại GET - yêu cầu không thay đổi gì phía nhà môi giới."""
    url = f"{host}/v3/instruments/{instrument}/candles"
    headers = {"Authorization": f"Bearer {token}"}

    for attempt in range(1, MAX_ATTEMPTS + 1):
        delay = BACKOFF_S * 2 ** (attempt - 1)
        try:
            response = session.get(url, headers=headers, params=parameters, timeout=TIMEOUT_S)
        except requests.RequestException as error:
            if attempt == MAX_ATTEMPTS:
                raise ApiError(f"Không kết nối được sau {MAX_ATTEMPTS} lần thử") from error
            log.warning("lần thử %s: %s", attempt, error)
            time.sleep(delay)
            continue

        if response.status_code == 429:
            # Vượt giới hạn tần suất. Header Retry-After, nếu nhà môi giới trả về,
            # đáng tin cậy hơn tự phỏng đoán.
            try:
                wait = float(response.headers.get("Retry-After", delay))
            except (TypeError, ValueError):
                # Đặc tả cũng cho phép ngày HTTP thay vì số giây;
                # thiếu nhánh này, float() sẽ làm hỏng toàn bộ việc tải dữ liệu.
                wait = delay
            log.warning("giới hạn tần suất, chờ %.1f s", wait)
            time.sleep(wait)
            continue

        if 500 <= response.status_code < 600:
            log.warning("lỗi máy chủ %s, thử lại", response.status_code)
            time.sleep(delay)
            continue

        if response.status_code != 200:
            raise ApiError(f"HTTP {response.status_code}: {response.text[:200]}")

        try:
            data = response.json()
        except ValueError as error:
            raise ApiError("Phản hồi JSON không hợp lệ") from error
        if not isinstance(data, dict):
            raise ApiError("Phản hồi JSON phải là đối tượng")
        if not isinstance(data.get("candles"), list) or not data["candles"]:
            raise ApiError("Phản hồi không có nến - kiểm tra công cụ và khoảng ngày")
        return data

    raise ApiError(f"Không có phản hồi hợp lệ sau {MAX_ATTEMPTS} lần thử")

Tình trạng xác minh: kiểm thử ngoại tuyến, không kết nối nhà môi giới. Hàm fetch_candles() được công bố đã chạy với mô phỏng phiên HTTP trong bộ nhớ, thay vì máy chủ thật. Chín kịch bản bao gồm 429 với Retry-After tính bằng giây, tiếp đến là 503 rồi thành công trong cùng một kịch bản; danh sách nến rỗng, 404, tiêu đề ngày HTTP, hết lần thử, ngoại lệ kết nối, JSON không hợp lệ, phản hồi không phải đối tượng và kiểu candles không hợp lệ. Các lần gọi sleep() được thay bằng bản ghi độ trễ yêu cầu; kiểm thử không mở socket và không đo thời gian mạng. Môi trường: Python 3.12.10, requests 2.34.2, Windows 11, kiểm tra 2026-10-08. Báo cáo kịch bản thực tế:

A: 429 giây -> 503 -> 200: số lần gọi=3; chờ=[3.0, 2.0]; một nến
B: nến rỗng: số lần gọi=1; chờ=[]; lỗi dự kiến
C: HTTP 404: số lần gọi=1; chờ=[]; lỗi dự kiến
D: phương án dự phòng ngày HTTP: số lần gọi=2; chờ=[1.0]; một nến
E: giới hạn thử lại: số lần gọi=4; chờ=[0.0, 0.0, 0.0, 0.0]; lỗi dự kiến
F: lỗi truyền tải: số lần gọi=4; chờ=[1.0, 2.0, 4.0]; lỗi dự kiến
G: JSON không hợp lệ: số lần gọi=1; chờ=[]; lỗi dự kiến
H: JSON không phải đối tượng: số lần gọi=1; chờ=[]; lỗi dự kiến
I: sai kiểu dữ liệu nến: số lần gọi=1; chờ=[]; lỗi dự kiến

Kết quả này xác nhận và không xác nhận điều gì. Nó xác nhận hành vi kỳ vọng trong chín kịch bản chuẩn bị sẵn. A kiểm tra 429 chọn độ trễ ba giây từ máy chủ thay vì một giây trong mã; D kiểm tra phương án dự phòng khi float() không phân tích được ngày HTTP. F kiểm tra có truyền timeout=10, thực hiện bốn lần thử và kết thúc bằng ngoại lệ sau lỗi truyền tải mô phỏng. Nó không xác lập hạn chót cho kết nối thật: timeout của requests không phải hạn tổng cho tác vụ, và việc chờ ở đây được mô phỏng. B, C và G–I kiểm tra từ chối phản hồi rỗng hoặc không hợp lệ. Kiểm thử không xác minh tính khả dụng API, mọi trường dữ liệu hay hành vi mạng tại nhà môi giới cụ thể.

Tuy nhiên, nó không xác nhận gì về chính nhà môi giới. Đường dẫn điểm cuối, tên tham số, cấu trúc phản hồi và việc nhà cung cấp có trả Retry-After hay không là đặc tính của API cụ thể [TÍNH NĂNG TÙY NHÀ MÔI GIỚI/TÀI KHOẢN], cần đọc tài liệu và kiểm thử trên tài khoản thực hành. Mô phỏng chứng minh mã của bạn xử lý đúng, không chứng minh giả định về máy chủ của người khác đúng — đó là toàn bộ giá trị của phép thử.

Phải đo độ trễ, không dẫn lại. Các khoảng truyền nhau trong hướng dẫn — “50–200 ms cho API này, 100–500 ms cho API kia” — vô giá trị vì không nêu vị trí máy khách, đường truyền, thời điểm hay cách đo. Thay vì chép số người khác, tách rõ thứ đang đo: thời gian phản hồi điểm cuối dữ liệu, từ gửi lệnh tới xác nhận nhận lệnh, tới xác nhận khớp và tuổi dữ liệu thị trường khi quyết định. Đó là bốn đại lượng khác nhau; chỉ một được gọi nôm na là “độ trễ”. Đo từng đại lượng trong chuỗi của mình, ghi nhật ký và dẫn kèm ngày, nhà môi giới, số lần thử. Ping ICMP không phải bất kỳ giá trị nào trong bốn giá trị đó.

Hỏi định kỳ hay luồng dữ liệu. Khi hỏi REST định kỳ, tuổi dữ liệu tùy khoảng giữa yêu cầu: hỏi mỗi năm giây nghĩa là trường hợp xấu nhất quyết định dựa trên giá năm giây trước; hỏi thường hơn tiêu hao hạn mức. Luồng — WebSocket hoặc HTTP streaming tùy API — đảo cách làm: máy chủ gửi khi có cập nhật. Nó hợp lý khi cần phản ứng trong nến hoặc hỏi định kỳ làm cạn hạn mức. Với chiến lược vào đầu nến H1 tiếp theo, hỏi định kỳ là đủ và dễ duy trì hơn. Luồng lại thêm ba vấn đề. Thứ nhất, khoảng trống sau kết nối lại: mất kết nối ba mươi giây thì socket không tự phát lại ba mươi giây ấy — phải lấy đoạn thiếu qua yêu cầu lịch sử riêng trước khi coi chuỗi là đầy đủ. Thứ hai, phát hiện kết nối chết: socket ngừng gửi trông giống hệt thị trường không có hoạt động, nên cần tín hiệu hiện diện như heartbeat hoặc keep-alive và bộ đếm im lặng riêng để tuyên bố kết nối hỏng rồi tạo lại. Thứ ba, thứ tự và bản ghi trùng: sau phục hồi có thể nhận lại thông điệp đã xử lý. Giống vấn đề lệnh, cách giải quyết là định danh sự kiện và kiểm tra đã ghi nhận chưa.

Giới hạn riêng cho dữ liệu và lệnh. API nghiêm túc tách luồng giá với luồng giao dịch; hạn mức thao tác đổi trạng thái tài khoản đôi khi thấp hơn nhiều so với đọc. Mã cố sửa dừng lỗ hàng chục lần mỗi giây khi thị trường căng có thể bị ngắt đúng đường giao dịch, để lại vị thế mở tạm thời không thể truy cập bằng chương trình. Vì vậy phải tự giới hạn tốc độ sửa, không trông chờ nhà môi giới bỏ qua.

8. Từ notebook tới dịch vụ: mã thực thi khác tập lệnh ra sao

Đây là ranh giới thực sự của bài. Notebook tính thống kê nhật ký có thể hỏng giữa chừng mà không sao — chạy lại là được. Mã có quyền tác động tài khoản sau cùng lỗi ấy để lại trạng thái: vị thế mở, lệnh mới sửa một phần, vào trùng. Khác biệt không nằm ở chất lượng mã mà ở hậu quả không thể đảo ngược của một trong hai loại.

Ba mức tự động hóa – khác nhau ở người ra quyết định cuối, không ở công nghệ:

Mức 1: thông báo. Mã kiểm tra điều kiện rồi gửi thông báo. Không truy cập tài khoản; không cần token đặt lệnh. Con người quyết định và thực thi. Chỉ ở mức này, lỗi mã không tốn gì ngoài bực bội.

Mức 2: chuẩn bị và chờ xác nhận. Mã dựng lệnh — công cụ, chiều, quy mô — rồi chờ người vận hành xác nhận rõ ràng, sau đó mới gửi. Mức này bắt lỗi tính toán trước khi thành vị thế và giữ con người trong vòng quyết định. Với người giao dịch cá nhân không định duy trì phần mềm, đây thường là đích đến chứ không phải bước chuyển — nhưng đó là nhận định biên tập, không phải kết quả nghiên cứu.

Mức 3: chạy không cần xác nhận. Mã tự mở và đóng vị thế. Cần mọi yếu tố trong khung trên, thử trên tài khoản thực hành rồi tài khoản có quy mô tối thiểu, và giám sát giai đoạn đầu. Bao nhiêu giao dịch mới đủ để chuyển tiếp là câu hỏi về cỡ mẫu và lực kiểm định, không phải một số tròn; nó thuộc bài về kiểm thử.

Lớp thực thi có các cổng an toàn

Nếu đưa mã đặt lệnh, phải đưa cả thứ ngăn nó. Mô-đun dưới chạy được trọn vẹn và không có lời gọi mạng nào: dựng lệnh, kiểm tra giới hạn rồi dừng ở các cổng. Phần gửi là đoạn riêng — được chủ ý trình bày ngoài dạng mã thực thi.

"""Lớp thực thi: xác thực, chế độ kiểm thử và cổng rõ ràng trước chế độ thực."""
import logging
import os
import sys
import uuid

ALLOWED_INSTRUMENTS = {"EUR_USD"}
MAX_UNITS = 1_000          # đơn vị đồng tiền cơ sở, không phải lot - quy ước tùy API

# Không thể đọc chấp thuận chế độ thực từ tệp này vì không nằm ở đây.
# Chương trình lấy từ biến môi trường và chấp nhận giá trị đúng là
# số tài khoản mà người vận hành chủ động muốn giao dịch - tự gõ trong shell
# trước khi khởi chạy. Phạm vi hàng rào được mô tả trong khung dưới đầu ra kiểm thử.
CONFIRMATION_VARIABLE = "BROKER_LIVE_CONFIRMATION"

# Thiếu cấu hình này sẽ không có mục log.info: mức root mặc định
# là WARNING và không có nơi ghi. Tệp để lại dấu vết sau sự cố, còn
# luồng hiển thị cùng thông tin trực tiếp. Trong chương trình lớn, cấu hình ghi nhật ký
# thuộc điểm vào chương trình, không thuộc mô-đun.
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(name)s %(message)s",
    handlers=[logging.FileHandler("execution.log", encoding="utf-8"),
              logging.StreamHandler(sys.stdout)],
)

log = logging.getLogger("execution")


class SafetyGateError(RuntimeError):
    """Chặn lệnh trước khi rời tiến trình."""


def new_order_id() -> str:
    """Gọi MỘT LẦN cho mỗi ý định đặt lệnh và lưu trước khi gửi.

    Mọi lần thử tiếp theo của cùng lệnh phải trả lại cùng giá trị -
    nếu không sẽ không có cơ sở nhận diện trùng lặp.
    """
    return str(uuid.uuid4())


def build_order(instrument: str, units: int, order_id: str) -> dict:
    if instrument not in ALLOWED_INSTRUMENTS:
        raise SafetyGateError(f"Công cụ không thuộc danh sách cho phép: {instrument}")
    # bool là lớp con của int nên isinstance(True, int) là đúng: nếu không loại bỏ rõ ràng,
    # giá trị logic sẽ qua xác thực và lọt vào payload.
    if isinstance(units, bool) or not isinstance(units, int) or units == 0:
        raise SafetyGateError("Quy mô phải là số nguyên khác không")
    if abs(units) > MAX_UNITS:
        raise SafetyGateError(
            f"Quy mô {abs(units)} vượt giới hạn {MAX_UNITS}")
    return {
        "order": {
            "type": "MARKET",
            "instrument": instrument,
            "units": str(units),
            # Mã định danh đến từ bên ngoài và không đổi giữa các lần thử.
            # Nếu tạo tại đây, mỗi lần thử lại sẽ mang giá trị khác.
            # Tên trường và các ràng buộc thuộc API cụ thể.
            "clientExtensions": {"id": order_id},
        }
    }


def _operator_confirmation() -> str:
    """Đọc giá trị từ bên ngoài tệp. Mã không biết và không lưu giá trị đó."""
    return os.environ.get(CONFIRMATION_VARIABLE, "").strip()


def submit_order(session, cfg, instrument: str, units: int, order_id: str,
                  test_mode: bool = True) -> dict | None:
    """Mặc định không gửi gì. Máy chủ thực yêu cầu hai quyết định."""
    order = build_order(instrument, units, order_id)

    if test_mode:
        log.info("CHẾ ĐỘ KIỂM THỬ [%s] đã tạo lệnh, chưa gửi gì: %s",
                 cfg.environment, order)
        return None

    if cfg.environment == "live" and _operator_confirmation() != cfg.account:
        raise SafetyGateError(
            "Máy chủ thực yêu cầu người vận hành xác nhận rõ ràng")

    # Các cổng kiểm soát đã qua - mô-đun kết thúc tại đây. Nó không gửi lệnh,
    # vì không có cách chạy trung thực; cấu trúc được mô tả trong phác thảo dưới.
    raise NotImplementedError(
        "Mô-đun không triển khai gửi lệnh - xem phác thảo cấu trúc")

Định danh lệnh được tạo một lần, không phải mỗi lần thử. Muốn nhận ra trùng lặp sau mất kết nối, giá trị phải được tạo khi hình thành ý định đặt lệnh, lưu bền vững trước khi gửi và dùng lại cho mọi lần thử của cùng lệnh ấy. Nếu uuid.uuid4() nằm trong bước dựng lệnh, mỗi lần thử lại sẽ gửi giá trị khác, không còn cơ sở coi yêu cầu thứ hai là lặp yêu cầu đầu. Vì thế build_order() nhận định danh qua đối số, không tự tạo.

Định danh ấy không giải quyết điều gì. Trường clientExtensions trong dữ liệu gửi trên là giải pháp của một nhà cung cấp, không phải chuẩn ngành, cũng không phải bảo đảm lũy đẳng đã được tài liệu hóa. Tài liệu OANDA mô tả đó là dữ liệu tùy chỉnh không bắt buộc gắn với lệnh và cảnh báo riêng: “Không đặt, sửa hay xóa tradeClientExtensions nếu tài khoản liên kết MT4” ^[14] (kiểm tra 2026-08-22). Không có lời hứa lệnh thị trường lặp cùng định danh sẽ bị từ chối là trùng — lệnh thị trường khớp ngay nên cửa sổ nhận ra trùng rất nhỏ. Nhận biết trùng do đó dựa vào hai điều phía bạn: sổ ý định bền vững ghi trước khi gửi, và đối soát với danh sách lệnh, giao dịch lấy từ nhà môi giới sau sự cố. Kiểm tra tên trường và ràng buộc trong tài liệu API của mình — nhà cung cấp khác đặt tên khác hoặc không có trường đó.

Gửi lệnh: phác thảo cấu trúc

Dưới đây không có hàm để sao chép. Đây là phác thảo cấu trúc: thứ tự bước và tên thao tác đủ để chuyển vào mã riêng, nhưng không thể dán và chạy. Hình thức này là lựa chọn có chủ ý. Ban biên tập không chạy nhánh này và không định chạy: gửi lệnh cần tài khoản tại nhà môi giới; kiểm tra mã giao dịch trên tài khoản người khác không phải thử nghiệm mà là rủi ro của họ. Đưa hàm hoàn chỉnh sẽ tạo hiện vật chưa ai chạy, chủ yếu dạy người đọc tin mã chưa xác minh. Chúng tôi chọn tương tự cho phác thảo MQL trong bài 11.5 và phác thảo Pine Script trong bài 11.2.

PHÁC THẢO CẤU TRÚC - gửi lệnh và xử lý khi không nhận phản hồi
Ký hiệu định hướng cho lớp HTTP. Đây không phải mã hoàn chỉnh có thể chạy.

khai báo: StanNieznany - phản hồi chưa đến nên chưa biết
          lệnh có tồn tại không. Đây là kiểu riêng, không phải lớp con của lỗi mạng:
          lỗi mạng có thể thử lại, trạng thái này tuyệt đối không được thử lại.

đầu vào: lệnh (đã tạo và xác thực), order_id, cấu hình, phiên HTTP
đầu ra:  phản hồi nhà môi giới hoặc StanNieznany - không bao giờ im lặng báo thành công

1. SỔ GHI BỀN VỮNG - trước mọi việc khác
   ghi bên ngoài bộ nhớ tiến trình: order_id, dấu thời gian UTC,
   công cụ, units, môi trường, status := INTENT
   buộc ghi xuống đĩa trước khi tiếp tục
   thiếu bước này, khởi động lại tiến trình sẽ mất thông tin về ý định,
   rồi chương trình không biết mình đã thử gì trước đó

2. NHẬT KÝ - cũng trước khi gửi
   ghi nhật ký: order_id + môi trường + nội dung lệnh
   không bao giờ đưa token vào nhật ký
   che số tài khoản, chỉ để bốn ký tự cuối
   con người đọc nhật ký sau sự kiện; chương trình đọc sổ ghi ở bước 1

3. MỘT YÊU CẦU, KHÔNG THỬ LẠI
   POST đến đường dẫn đặt lệnh theo tài liệu API của bạn
   header xác thực chứa token lấy từ cấu hình, tuyệt đối không lấy từ mã
   bắt buộc có timeout - thiếu nó, lời gọi có thể treo mãi

4. KHÔNG NHẬN ĐƯỢC PHẢN HỒI (timeout hoặc lỗi truyền tải)
   KHÔNG thử lại - POST không có tính lũy đẳng
   trạng thái trong sổ ghi := UNKNOWN
   phát sinh StanNieznany
   ĐỐI SOÁT TRẠNG THÁI: hỏi nhà môi giới về lệnh và giao dịch khớp
   trong vài phút gần nhất, tìm order_id trong đó; chỉ sau khi xác định
   lệnh có tồn tại không mới đưa ra quyết định mới
   (phác thảo không có quy trình này - xem đoạn bên dưới)

5. ĐÃ NHẬN PHẢN HỒI
   ghi nhật ký: mã HTTP + phần nội dung phản hồi đã rút gọn
   nếu mã ngoài (200, 201) -> status := REJECTED -> phát sinh lỗi
   nếu nội dung không phải JSON -> status := UNKNOWN -> phát sinh StanNieznany
   nếu không                   -> status := ACCEPTED -> trả về phản hồi

những gì phác thảo này không có và không thể có:
   không có hàm làm sẵn có thể dán vào và chạy với tài khoản,
   cũng không nêu tên trường mức bảo vệ, vì điều đó đến từ tài liệu
   API cụ thể chứ không phải ví dụ của người khác.

Phác thảo này không làm gì – điều đó quan trọng ngang phần nó mô tả. Nó không thêm mức bảo vệ: cả dừng lỗ lẫn chốt lời đều thiếu. Đây không phải bỏ sót — quy ước biểu diễn khác giữa API: trường riêng, khoảng cách hay giá tuyệt đối, thời hạn hiệu lực riêng. Đoạn đó phải lấy từ tài liệu nhà môi giới của bạn, không từ ví dụ người khác. Hệ quả thực tế liên quan chính bước 4: sau StanNieznany, bạn có thể có vị thế mở không được bảo vệ mà còn không chắc nó tồn tại. Trong mã được phép gửi lệnh, mức bảo vệ phải đi cùng yêu cầu vào lệnh — nếu không sẽ có khoảng thời gian vị thế sống mà chưa có dừng lỗ.

Không chỉ thiếu mức bảo vệ. Từ danh sách “Notebook nghiên cứu ≠ chương trình thực thi”, cả mô-đun chạy được ở trên và phác thảo này đều chưa có giám sát, công tắc dừng hay quy trình triển khai; trạng thái tồn tại qua khởi động lại chỉ xuất hiện ở bước 1 của phác thảo dưới dạng yêu cầu, chưa được triển khai. Phần nhật ký, trạng thái và kiểm thử bàn về các yếu tố ấy — chỉ bàn, không thể hiện bằng mã. Kết luận vẫn như trong khung: đây là tài liệu học kiến trúc, không phải chương trình thực thi.

Các cổng an toàn đã được kiểm tra ngoại tuyến – không mạng, không nhà môi giới, không bí mật, dùng cấu hình giả lập. Dưới đây là toàn bộ kiểm thử, không chỉ đầu ra; thiếu nó, bạn phải tin lời chúng tôi — chính kiểu tin tưởng mà bài này cảnh báo.

"""Kiểm thử cổng kiểm soát không dùng mạng: cấu hình giả lập, không bí mật, không POST."""
from dataclasses import dataclass


@dataclass(frozen=True)
class MockConfiguration:
    environment: str = "practice"
    host: str = "https://api-fxpractice.oanda.com"
    token: str = "dummy-token-for-offline-test"
    account: str = "000-000-0000000-000"


def test_gates() -> None:
    cfg = MockConfiguration()
    order_id = new_order_id()
    print("cấu hình:", cfg.environment, cfg.host, "token_length=", len(cfg.token))

    # Cố ý đặt session=None: nếu mã vẫn cố gửi POST,
    # kiểm thử sẽ phát sinh AttributeError thay vì im lặng vượt qua.
    result = submit_order(None, cfg, "EUR_USD", 100, order_id)
    assert result is None
    print("1. chế độ kiểm thử: chưa gửi gì - OK")

    for description, instrument, units in [
        ("công cụ không thuộc danh sách cho phép", "GBP_JPY", 100),
        ("quy mô vượt giới hạn", "EUR_USD", 5000),
        ("quy mô bằng không", "EUR_USD", 0),
        ("giá trị logic thay vì số", "EUR_USD", True),
    ]:
        try:
            build_order(instrument, units, order_id)
        except SafetyGateError as error:
            print(f"2. cổng [{description}]:", error)
        else:
            raise AssertionError(f"Cổng kiểm soát dự kiến không được kích hoạt: {description}")

    cfg_live = MockConfiguration(environment="live", host="https://api-fxtrade.oanda.com")
    try:
        submit_order(None, cfg_live, "EUR_USD", 100, order_id, test_mode=False)
    except SafetyGateError as error:
        print("3. cổng [chế độ thực chưa xác nhận]:", error)
    else:
        raise AssertionError("Chế độ thực vượt qua mà không xác nhận")

    print("mọi cổng kiểm soát đã vượt qua")


if __name__ == "__main__":
    test_gates()

Đầu ra lần chạy — Python 3.12.10 như phần 2, không mạng và không cần gói ngoài thư viện chuẩn: bỏ phần gửi đi thì mô-đun thực thi không còn cần requests. Dòng thứ hai là mục nhật ký: cùng nội dung đồng thời đi vào tệp execution.log và đầu ra chuẩn. Dấu thời gian và định danh lệnh thay đổi mỗi lần chạy — phần còn lại lặp lại chính xác từng ký tự:

cấu hình: practice https://api-fxpractice.oanda.com token_length= 28
1. chế độ kiểm thử: chưa gửi gì - OK
2. cổng [công cụ không thuộc danh sách cho phép]: Công cụ không thuộc danh sách cho phép: GBP_JPY
2. cổng [quy mô vượt giới hạn]: Quy mô 5000 vượt giới hạn 1000
2. cổng [quy mô bằng không]: Quy mô phải là số nguyên khác không
2. cổng [giá trị logic thay vì số]: Quy mô phải là số nguyên khác không
3. cổng [chế độ thực chưa xác nhận]: Máy chủ thực yêu cầu người vận hành xác nhận rõ ràng
mọi cổng kiểm soát đã vượt qua

Đầu ra này xác nhận và không xác nhận điều gì. Năm trường hợp âm kích hoạt đúng cổng: công cụ ngoài danh sách cho phép, quy mô quá lớn, bằng không, giá trị boolean và chế độ thật không xác nhận. Assertion còn kiểm tra chế độ thử; lần kiểm toán cũng kiểm tra biên ±1000, vượt giới hạn và kiểu không hợp lệ. Đối số gọi đầu tiên là None, và chưa triển khai gửi, nên kiểm thử không thể đặt lệnh. Đầu ra không kiểm tra API nhà môi giới, độ bền ghi nhật ký hay che mọi trường nhạy cảm. Token giả không được in: chỉ hiển thị độ dài. Trong dự án riêng, cần kiểm tra riêng việc ghi và phục hồi nhật ký, quy tắc che dữ liệu và lỗi ổ đĩa.

Tuy nhiên, nó không xác nhận hành vi với API thật — cũng không thể, vì mô-đun không có nhánh gửi lệnh. Phác thảo cấu trúc thay nhánh ấy và loại nơi duy nhất có thể gửi gì đó. Đó là khác biệt giữa “chưa chạy” và “không có gì để chạy”: cách đầu để lại hiện vật sẵn dán, cách sau để cấu trúc người đọc phải tự triển khai, đồng thời đọc tài liệu nhà môi giới của mình.

Kiểm thử cũng phải phát hiện thiếu cổng an toàn. Vì thế nó xác nhận kết quả chế độ thử và phát sinh AssertionError sau từng trường hợp âm nếu ngoại lệ kỳ vọng không xuất hiện. Thông báo cuối chỉ xuất hiện sau khi các kiểm tra qua. Đây vẫn là ví dụ nhỏ: không bao phủ định dạng phản hồi nhà môi giới, mọi kiểu dữ liệu hay phục hồi trạng thái. Dự án lớn nên chuyển các ca sang pytest, thêm ca dương và chạy mỗi khi bộ xác thực thay đổi.

Đơn vị không phải lot. Chú thích cạnh MAX_UNITS không phải trang trí. API dùng quy ước quy mô khác nhau — đơn vị đồng cơ sở, lot, hợp đồng — và nhầm ở đây không gây lỗi cú pháp hay ngoại lệ. Nó tạo phơi nhiễm lớn hơn dự định hai hoặc ba bậc độ lớn trong khi mã vẫn chạy đúng. Trước khi gửi gì, kiểm tra tài liệu và xác nhận bằng một giao dịch quy mô tối thiểu trên tài khoản thực hành. Cần biết hai giới hạn của bộ xác thực trước khi đưa vào phép tính riêng. Quy mô tính trong pandas hoặc NumPy có kiểu numpy.int64, không phải lớp con của kiểu tích hợp int — bộ xác thực từ chối với thông báo về số nguyên dù giá trị đúng là số nguyên. Nó thất bại an toàn nhưng khó hiểu, nên chuyển số đọc từ DataFrame qua int(...) trước khi đưa tới build_order(). Giới hạn thứ hai: order_id hoàn toàn chưa được kiểm tra; chú thích kiểu không cưỡng chế gì. Vì nhận biết lệnh trùng dựa vào định danh đó, hãy kiểm tra độ dài, định dạng được phép trong tài liệu API rồi cưỡng chế như giới hạn quy mô.

Nhật ký, trạng thái và kiểm thử

Ghi nhật ký thay cho print(). Mô-đun logging có cấp độ nghiêm trọng, dấu thời gian và ghi tệp — nhưng không thứ nào tự bật. Chưa cấu hình thì mức mặc định là WARNING và chưa có đích ghi, nên các lần gọi log.info(...) bị bỏ âm thầm: mã trông như ghi nhật ký nhưng không ghi gì. Đó là nguyên nhân lặp lại khiến nhật ký trống sau sự cố. Chỉ cấu hình một lần tại điểm vào chương trình — trong tập lệnh được chạy, không trong mô-đun nhập vào. Lần gọi logging.basicConfig(...) nằm trong mô-đun thực thi trên chỉ vì ở đây mô-đun cũng là toàn bộ chương trình; chú thích trong mã nói rõ dự án lớn không nên đặt ở đó. Lý do cụ thể: cấu hình trong mô-đun chạy lúc import, chiếm cấu hình ghi log cho cả tiến trình; lần gọi logging.basicConfig(...) sau đó ở điểm vào thật sẽ không làm gì — hàm không có tác dụng khi bộ ghi gốc đã có đích, trừ khi gọi với force=True) và không báo lỗi ^[4]. Thiết lập của bạn biến mất; mục ghi đi tới nơi mô-đun nhập đã chỉ định: cùng lỗi âm thầm, chỉ từ phía khác. Ghi quyết định và căn cứ, nội dung yêu cầu, phản hồi máy chủ — cắt ngắn phản hồi để trang lỗi HTML không làm ngập nhật ký, tăng giới hạn khi chẩn đoán. Token là ngoại lệ: không bao giờ ghi. Thiếu phản hồi nhà môi giới, sau này không thể biết vấn đề nằm ở logic, mạng hay máy chủ.

Trạng thái phải tồn tại qua khởi động lại. Sớm muộn tiến trình sẽ dừng — do cập nhật hệ thống, mất điện hoặc chính bạn nhấn Ctrl+C. Nếu thông tin lệnh đã gửi chỉ ở bộ nhớ, sau khởi động lại chương trình không biết mình đã làm gì. Tối thiểu phải ghi định danh lệnh vào tệp hoặc cơ sở dữ liệu trước khi gửi, rồi khi khởi động đối chiếu với trạng thái tài khoản lấy từ API. Chính quy trình ấy ngăn vào trùng sau mất kết nối.

Kiểm thử không cần mạng. Logic tín hiệu và xác thực giới hạn kiểm tra được trên dữ liệu chuẩn bị sẵn, không kết nối gì — như phần cổng an toàn ở trên. Kiểm thử cần API hoạt động không phải kiểm thử đơn vị và không thể chạy mỗi khi sửa mã. Bắt đầu từ thứ kiểm tra ngoại tuyến được: điều kiện vào, tính quy mô, hành vi với dữ liệu rỗng và có khoảng trống.

Dừng có kiểm soát. Chương trình thực thi nên phản ứng với tín hiệu kết thúc: hoàn tất thao tác hiện tại, lưu trạng thái rồi thoát, thay vì bị cắt giữa lúc gửi lệnh. Riêng biệt, nên có điều kiện ngăn điểm vào mới khi vượt ngưỡng lỗ ngày. Đặt ngưỡng ở đâu và tính thế nào nằm trong phần quản trị rủi ro của khóa học; trong mã đó là điều kiện thường kiểm tra trước từng lần vào, không phải hàm thư viện.

Xem thêm: Giao dịch thuật toán – kiến trúc hệ thống và vị trí tự động hóa trong toàn bộ quá trình quyết định.

9. Thiên lệch nhìn trước và rò rỉ dữ liệu trong mã Python

Thiên lệch nhìn trước không phải lỗi phương pháp ở đây. Nó là lỗi của một dòng mã — vì thế thuộc bài này, không phải bài phương pháp kiểm thử. Kết quả gán cho một thời điểm dùng thông tin chưa tồn tại tại thời điểm đó.

Dạng phổ biến nhất trong pandas rất đơn giản: cột tín hiệu nhân cột lợi nhuận cùng dòng. Lợi nhuận ở dòng t phát sinh từ lúc đóng nến trước tới lúc đóng nến t. Tín hiệu tính từ giá đóng nến t chỉ được biết khi lợi nhuận ấy đã xảy ra. Nhân chúng với nhau là tự nhận kết quả của chuyển động chưa biết lúc ra quyết định.

Giả định ví dụ dưới: tám quan sát giờ tổng hợp, chỉ số UTC, giá trị minh họa, không chi phí giao dịch — mục tiêu là thể hiện cơ chế dịch, không đánh giá quy tắc. Môi trường như phần 2: Python 3.12.10, pandas 3.0.5.

"""Nhìn trước tương lai trong một dòng: cùng quy tắc, hai kết quả khác nhau."""
import pandas as pd

index = pd.date_range("2026-06-01", periods=8, freq="1h", tz="UTC")
df = pd.DataFrame(
    {"close": [1.0800, 1.0810, 1.0825, 1.0815, 1.0830, 1.0845, 1.0840, 1.0855]},
    index=index,
)
df["sma"] = df["close"].rolling(3).mean()
df["return"] = df["close"].pct_change()

# Quy tắc: vị thế mua khi giá đóng cửa cao hơn trung bình ba nến.
df["position"] = (df["close"] > df["sma"]).astype(int)

# SAI: vị thế của hàng t nhân với lợi suất cùng hàng đó.
# Lợi suất t hình thành giữa giá đóng cửa t-1 và giá đóng cửa t, nên quyết định
# dùng mức giá chưa tồn tại tại thời điểm vào lệnh.
df["result_with_lookahead"] = df["position"] * df["return"]

# ĐÚNG: vị thế quyết định lúc đóng cửa t chỉ hưởng lợi suất t+1.
df["result_without_lookahead"] = df["position"].shift(1) * df["return"]

print(df[["result_with_lookahead", "result_without_lookahead"]].sum().round(6))

Đầu ra lần chạy:

result_with_lookahead       0.005082
result_without_lookahead    0.001384
dtype: float64

Diễn giải. Cùng quy tắc, cùng dữ liệu, khác một lần gọi shift(1) — tổng lợi nhuận đơn từng kỳ giảm từ 0,005082 xuống 0,001384, tức dưới 30 phần trăm giá trị đầu. Tám quan sát đương nhiên chỉ minh họa, không phải phép đo; trên nhiều năm dữ liệu, cùng lỗi có thể biến chiến lược trung bình thành ngoạn mục, và ngoạn mục thành bất khả thi. Cả hai không có đơn vị và chưa tính spread hay hoa hồng — tính vào thì bản đúng còn thấp hơn.

Một lưu ý về phép tính. pct_change() cho lợi nhuận đơn; như phần 4 đã nói, chúng ghép bằng phép nhân, không cộng; chỉ lợi nhuận log mới cộng được. Ở đây cộng là xấp xỉ có chủ ý, vì với mức cỡ phần nghìn, chênh lệch giữa tổng và ghép đúng trong ví dụ nhỏ hơn 0,00001, tức thấp hơn hơn hai bậc độ lớn so với chênh lệch cần thể hiện. Khi tính kết quả tài khoản thay vì cơ chế dịch, hãy nhân dồn (1 + r) hoặc chuyển sang lợi nhuận log rồi mới cộng.

Cẩn thận dịch hai lần. Chỉ dịch ở một nơi: cột vị thế hoặc dữ liệu đầu vào tín hiệu, không đồng thời cả hai. Mã tính tín hiệu từ giá đã dịch rồi lại dịch vị thế sẽ làm trễ hai kỳ và âm thầm hạ kết quả. Lỗi hướng này ít nguy hiểm hơn nhìn trước nhưng vẫn sai.

Các dạng nhìn trước khác trong mã Python – đều quy về một câu hỏi: giá trị đã biết lúc quyết định chưa?

• Dùng giá cao hoặc thấp của nến hiện tại để vào, dù chỉ biết chúng sau khi nến đóng
• Định tỷ lệ hoặc chuẩn hóa trên toàn bộ dữ liệu trước khi chia huấn luyện/xác thực — tham số biến đổi mang thông tin tương lai
• Chỉ báo làm mượt hay đánh dấu đảo chiều bằng nến sau; giá trị lịch sử khác điều thấy trực tiếp
• Dữ liệu vĩ mô sau điều chỉnh thay vì giá trị công bố ban đầu
• Lệnh được khớp giá đóng của nến tạo tín hiệu

Rò rỉ khi chuẩn bị tập dữ liệu. Mục thứ hai đáng có giải thích riêng, vì trong Python rất dễ làm theo phản xạ. Gọi bộ chuẩn hóa trên toàn DataFrame trước khi chia kỳ chỉ một dòng và trông vô hại, nhưng truyền kiến thức về phân bố tương lai vào phần xác thực. Chỉ xác định tham số biến đổi trên dữ liệu trước, rồi áp dụng lên dữ liệu sau — không đảo ngược.

Kiểm định nhiều lần. Càng thử nhiều biến thể trên cùng dữ liệu, càng có khả năng biến thể tốt nhất là trùng hợp. Với mô hình được nêu rõ cho giả thuyết không (null), nếu 10.000 kiểm định đều có xác suất dương giả 0,05, số kết quả kỳ vọng được gọi “có ý nghĩa” là 0,05 × 10.000 = 500. Kỳ vọng này do cộng xác suất, không cần độc lập; sự phụ thuộc đổi phân bố số lượng, không đổi trung bình trong các giả định đó. Bậc độ lớn cho thấy vì sao phải báo cáo số lần thử cùng kết quả.

Có hiệu chỉnh chính thức tính tới số lần thử — Deflated Sharpe Ratio, do Bailey và López de Prado đề xuất năm 2014 ^[12]. Trước khi dùng triển khai sẵn, hãy kiểm tra tình trạng và giấy phép thư viện; một số dự án lĩnh vực này đã đổi mô hình phân phối. Công thức gốc được mô tả trong công bố nguồn và có thể tự triển khai.

Phần này không bao gồm gì. Quá khớp, lựa chọn mẫu, phân tích cuốn chiếu, thiên lệch sống sót và kiểm tra độ vững khi chi phí tăng thuộc phương pháp kiểm thử, được mô tả trong bài về backtest và kiểm thử tiến. Ở đây chỉ quan tâm thứ có thể làm hỏng trong mã — và có thể kiểm tra trong mã.

Kiểm tra mã trước khi tin kết quả:

1. Kết quả dòng t có chỉ dùng dữ liệu có trước lúc quyết định không?
2. Có chỉ dịch đúng một lần — tín hiệu hoặc dữ liệu, không cả hai không?
3. Có ghi rõ thời điểm và giá khớp thay vì để ngầm định không?
4. Mô hình có chi phí giao dịch, hoặc chủ ý bỏ và nêu rõ không?
5. Dữ liệu có chia huấn luyện và xác thực theo thời gian không?
6. Các phép biến đổi có chỉ được xác định trên phần trước không?
7. Có ghi số biến thể đã thử cùng kết quả không?
8. Chỉ số thời gian có múi giờ rõ ràng, tăng dần và không trùng không?

10. Bạn thực sự cần bao nhiêu mã

Không cần thành lập trình viên. Cần biết đủ để không bị mã mình hoặc tập lệnh người khác tải từ kho đánh lừa.

Thời gian cột cuối chỉ ước tính, tùy điểm xuất phát và số giờ thực sự dành mỗi tuần — hãy coi là bậc độ lớn, không phải lời hứa.

Mức 1 và 2 không tạo lợi thế thị trường. Chúng cho khả năng kiểm tra giải pháp người khác có hợp lý không và ngừng mua hệ thống không thể xác minh. Đó là giá trị thật nhưng khác giá trị nhà bán công cụ sẵn quảng bá. Cần mức 4 nếu muốn duy trì chương trình thực thi, không phải để giao dịch tốt hơn. Giáo trình Hilpisch khảo sát ứng dụng Python trong tài chính ^[11], kèm lưu ý áp dụng mọi sách về mã: phải kiểm tra đoạn mã với thư viện hiện hành trước khi dùng vì một số giao diện đã đổi từ lúc xuất bản.

Thứ tự học hợp lý – mỗi bước dựa trên bước trước và kết thúc bằng thứ hoạt động được:

1. Kiến thức ngôn ngữ cơ bản – biến, danh sách, hàm, điều kiện. Đủ đọc mã người khác mà không phải đoán
2. pandas trên dữ liệu của bạn – tải bản xuất nhật ký, tính thống kê theo thứ và công cụ. Nếu thích học giáo trình hơn tài liệu, sách McKinney, tác giả pandas, bao phủ đầy đủ giai đoạn này ^[10]
3. Một biểu đồ – vẽ đường vốn và sụt giảm từ kết quả bước trước
4. Kiểm tra chất lượng dữ liệu – lặp ví dụ phần 4 trên tệp mình: múi giờ, trùng, khoảng trống
5. Tích hợp chỉ đọc – lấy dữ liệu API trên tài khoản thực hành, dùng token không có quyền giao dịch nếu nhà cung cấp phân quyền

Thứ tự có chủ ý. Bước thứ năm chỉ đến sau khi biết kiểm tra dữ liệu tải về — nếu không, bạn đang tự động hóa lỗi thay vì công việc.

Bắt đầu bằng một việc: tải dữ liệu của mình, tính thứ có thể kiểm tra tay trên ba dòng rồi so kết quả. Nếu Python khớp với đếm bằng tay, bạn có nền tảng. Nếu không, bạn vừa tìm lỗi đầu tiên — đó là khởi đầu tốt hơn mã chạy ngay mà bạn không hiểu.

Python không sửa được chiến lược tệ. Tốt nhất, nó cho thấy chiến lược tệ nhanh hơn.