1. Lập Kế Hoạch Hàng Ngày
Tạo danh sách công việc: Mỗi sáng, hãy viết ra những việc cần làm trong ngày và sắp xếp chúng theo mức độ ưu tiên.
Thời gian cụ thể: Đặt thời gian cụ thể cho từng nhiệm vụ để tránh việc kéo dài thời gian làm việc.

2. Sử Dụng Kỹ Thuật Pomodoro
Kỹ thuật Pomodoro: Làm việc trong 25 phút, sau đó nghỉ 5 phút. Sau bốn chu kỳ, nghỉ dài hơn (15-30 phút).
Tăng cường tập trung: Kỹ thuật này giúp bạn duy trì sự tập trung và giảm mệt mỏi.

3. Giảm Thiểu Sự Phân Tâm
Tắt thông báo: Tắt thông báo từ điện thoại và ứng dụng trong thời gian làm việc.
Tạo không gian làm việc yên tĩnh: Chọn một nơi làm việc không bị làm phiền để tối ưu hóa sự tập trung.

4. Sử Dụng Công Cụ Quản Lý Thời Gian
Ứng dụng quản lý: Sử dụng các ứng dụng như Trello, Todoist hoặc Asana để theo dõi tiến độ công việc.
Nhắc nhở và thời gian biểu: Thiết lập nhắc nhở cho các nhiệm vụ quan trọng.

5. Đánh Giá và Điều Chỉnh
Cuối ngày đánh giá: Dành thời gian vào cuối ngày để xem xét những gì đã hoàn thành và điều chỉnh kế hoạch cho ngày hôm sau.
Học từ trải nghiệm: Xem xét những gì hiệu quả và những gì không, để cải thiện quy trình làm việc của bạn.

Kết Luận
Việc tối ưu hóa thời gian làm việc không chỉ giúp bạn hoàn thành nhiệm vụ nhanh hơn mà còn giảm căng thẳng và tăng cường hiệu suất. Hãy thử áp dụng những mẹo này và theo dõi sự thay đổi trong công việc của bạn!

1. Giới Thiệu​

Trong phân tích định lượng, việc kiểm tra xem dữ liệu có tuân theo phân phối chuẩn hay không là rất quan trọng. Điều này ảnh hưởng đến việc áp dụng các mô hình thống kê và dự đoán. Hai phương pháp phổ biến để kiểm định tính chuẩn của dữ liệu là:

• Kiểm định Kolmogorov-Smirnov (KS Test)
• Kiểm định Shapiro-Wilk (SW Test)

2. Mã Python Kiểm Định Phân Phối Chuẩn​

from scipy.stats import kstest, shapiro
import pandas as pd

# Hàm kiểm định phân phối chuẩn
def test_normality(column):
    # KS Test
    ks_stat, ks_p_value = kstest(column, 'norm', args=(column.mean(), column.std()))
    
    # SW Test
    sw_stat, sw_p_value = shapiro(column)
    
    return ks_stat, ks_p_value, sw_stat, sw_p_value

# Gọi hàm
result = {}
for col in ['open', 'high', 'low', 'close', 'volume']:
    ks_stat, ks_p_value, sw_stat, sw_p_value = test_normality(data[col])
    result[col] = {
        'KS statistic': ks_stat,
        'KS p-value': ks_p_value,
        'SW statistic': sw_stat,
        'SW p-value': sw_p_value
    }

# Chuyển đổi result về DataFrame để hiển thị
normality_result_df = pd.DataFrame(result).T

# Hiển thị kết quả
print(normality_result_df)

3. Kết Quả​

4. Diễn Giải Kết Quả​

• KS Test: Nếu giá trị p-value nhỏ hơn 0.05, dữ liệu có thể không tuân theo phân phối chuẩn.
• SW Test: Nếu giá trị p-value nhỏ hơn 0.05, giả thuyết phân phối chuẩn bị bác bỏ.
• Trong kết quả trên, tất cả các cột đều có giá trị p-value nhỏ hơn 0.05 trong cả hai kiểm định, chứng tỏ dữ liệu không tuân theo phân phối chuẩn.

5. Kết Luận​

Kết quả kiểm định cho thấy dữ liệu không tuân theo phân phối chuẩn, điều này có thể ảnh hưởng đến các phương pháp phân tích thống kê tiếp theo. Khi đó, cần xem xét các phương pháp xử lý như biến đổi dữ liệu (log, sqrt), sử dụng các mô hình phi tuyến tính hoặc phương pháp không tham số.

Bài viết cung cấp kiến thức cơ bản về kiểm định phân phối chuẩn và cách áp dụng với dữ liệu tài chính thực tế.

Giới thiệu​

Trong phân tích chuỗi thời gian, Autocorrelation Function (ACF) và Partial Autocorrelation Function (PACF) là hai công cụ quan trọng giúp xác định mô hình ARIMA phù hợp.

• ACF đo lường mối quan hệ giữa một quan sát và các quan sát trước đó ở các độ trễ khác nhau.
• PACF giúp xác định bậc của thành phần tự hồi quy (AR) trong mô hình ARIMA.

Cài đặt thư viện cần thiết​

import numpy as np
import matplotlib.pyplot as plt
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf

Tạo dữ liệu mẫu​

# Tạo dữ liệu giả lập
np.random.seed(42)
y = np.random.randn(100)

Vẽ biểu đồ ACF và PACF​

# Tạo figure với 2 biểu đồ
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# ACF plot
plot_acf(y, ax=axes[0], lags=20)
axes[0].set_title('Autocorrelation Function (ACF)')

# PACF plot
plot_pacf(y, ax=axes[1], lags=20)
axes[1].set_title('Partial Autocorrelation Function (PACF)')

plt.tight_layout()
plt.show()

Kết luận​

• Nếu ACF giảm dần và PACF cắt mạnh tại một độ trễ nào đó, mô hình có thể phù hợp với AR.
• Nếu ACF cắt mạnh và PACF giảm dần, mô hình có thể phù hợp với MA.
• Nếu cả hai giảm dần, mô hình có thể phù hợp với ARMA.

Hãy thử áp dụng phân tích này vào dữ liệu thực tế của bạn! 🚀

Trong phân tích dữ liệu định lượng, việc xác định mối tương quan giữa các biến số là rất quan trọng. Bài viết này hướng dẫn cách tính toán ma trận tương quan kèm theo giá trị p-value để đánh giá ý nghĩa thống kê của mối quan hệ giữa các biến.

1. Nhập các thư viện cần thiết​

import pandas as pd
import numpy as np
import plotly.figure_factory as ff
from scipy.stats import pearsonr

2. Chuẩn bị dữ liệu​

Chúng ta chỉ lấy các cột số liệu để tính toán mối tương quan:

# Chỉ lấy các cột số liệu để tính toán
numeric_data = data[['open', 'high', 'low', 'close', 'volume']]

# Xử lý các giá trị NaN nếu có
numeric_data = numeric_data.dropna()

3. Tính toán ma trận tương quan và giá trị p-value​

# Tính toán ma trận tương quan
correlation_matrix = numeric_data.corr()

# Khởi tạo ma trận p-value
p_values = np.zeros_like(correlation_matrix)

# Tính toán p-values
for row in range(len(correlation_matrix)):
    for col in range(len(correlation_matrix)):
        if row != col:
            _, p_value = pearsonr(numeric_data.iloc[:, row], numeric_data.iloc[:, col])
            p_values[row, col] = p_value
        else:
            p_values[row, col] = np.nan  # Giữ NaN cho đường chéo chính

# Tạo DataFrame cho p-value
p_value_df = pd.DataFrame(p_values, columns=correlation_matrix.columns, index=correlation_matrix.index)

4. Kết hợp ma trận tương quan và p-value​

# Tạo annotation cho heatmap
annotations = correlation_matrix.round(2).astype(str) + "\n(p=" + p_value_df.round(3).astype(str) + ")"

5. Vẽ biểu đồ Heatmap với Plotly​

# Tạo danh sách annotation
z_text = annotations.values.tolist()

# Vẽ biểu đồ tương quan với Plotly
fig = ff.create_annotated_heatmap(
    z=correlation_matrix.values,
    x=correlation_matrix.columns.tolist(),
    y=correlation_matrix.index.tolist(),
    annotation_text=z_text,
    colorscale='RdBu',
    showscale=True
)

# Cập nhật tiêu đề
fig.update_layout(title='Ma trận tương quan với p-value', width=800, height=800)

# Hiển thị biểu đồ
fig.show()

6. Kết luận​

• Ma trận tương quan giúp chúng ta hiểu được mức độ liên quan giữa các biến số.
• Giá trị p-value giúp đánh giá ý nghĩa thống kê của mối tương quan.
• Nếu p-value nhỏ hơn 0.05, mối tương quan có ý nghĩa thống kê.

Với cách tiếp cận trên, chúng ta có thể xác định những mối tương quan quan trọng trong dữ liệu và đưa ra quyết định phân tích phù hợp hơn.

Trong phân tích chuỗi thời gian, việc kiểm tra thành phần xu hướng, chu kỳ và phần dư giúp hiểu rõ hơn về biến động của dữ liệu theo thời gian. Bài viết này hướng dẫn cách sử dụng phương pháp phân rã chuỗi thời gian (Seasonal Decomposition) để kiểm tra tính chu kỳ của biến 'close'.

1. Nhập các thư viện cần thiết​

import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.seasonal import seasonal_decompose

2. Đọc và xử lý dữ liệu​

# Load dữ liệu
data = pd.read_excel('ibm_data.xlsx')

# Chuyển đổi cột datetime về đúng định dạng
data['datetime'] = pd.to_datetime(data['datetime'])
data.set_index('datetime', inplace=True)

# Lấy biến mục tiêu
y = data['close']

3. Thực hiện phân rã chuỗi thời gian​

# Phân rã chuỗi thời gian với mô hình cộng (Additive Model)
result = seasonal_decompose(y, model='additive', period=12)

4. Vẽ biểu đồ các thành phần của chuỗi thời gian​

plt.figure(figsize=(14, 10))

plt.subplot(411)
plt.plot(result.observed, label='Observed')
plt.legend(loc='upper left')

plt.subplot(412)
plt.plot(result.trend, label='Trend')
plt.legend(loc='upper left')

plt.subplot(413)
plt.plot(result.seasonal, label='Seasonal')
plt.legend(loc='upper left')

plt.subplot(414)
plt.plot(result.resid, label='Residual')
plt.legend(loc='upper left')

# Lưu biểu đồ
plt.savefig("seasonal_decompose.png")
plt.show()

5. Kết luận​

• Thành phần trend cho thấy xu hướng dài hạn của biến 'close'.
• Thành phần seasonal giúp phát hiện các mẫu lặp lại theo chu kỳ.
• Thành phần residual phản ánh các biến động không giải thích được bởi xu hướng và mùa vụ.
• Kết quả này giúp nhà phân tích có thể xây dựng mô hình dự báo chính xác hơn dựa trên các thành phần của dữ liệu chuỗi thời gian.

Sau khi chạy đoạn mã trên, bạn sẽ có biểu đồ phân rã chuỗi thời gian và có thể hiển thị hình ảnh seasonal_decompose.png trên Docusaurus bằng cách:

Buổi 2: Thiết lập môi trường & Công cụ phát triển​

1. Cài đặt Flutter SDK, Dart SDK​

Để bắt đầu với Flutter, bạn cần cài đặt Flutter SDK và Dart SDK. Đảm bảo rằng bạn đã thiết lập môi trường phát triển đúng cách để có thể chạy ứng dụng Flutter.

2. Giới thiệu công cụ test API: Postman, Insomnia​

Khi làm việc với API, hai công cụ phổ biến là Postman và Insomnia. Những công cụ này giúp bạn kiểm tra và debug API nhanh chóng, đảm bảo dữ liệu trả về đúng như mong muốn.

3. Tạo dự án Flutter mới​

Sử dụng lệnh sau để tạo một dự án Flutter mới:

flutter create my_new_project
cd my_new_project
flutter run

Điều này sẽ tạo một dự án Flutter mới và chạy nó trên thiết bị giả lập hoặc thực tế.

4. Giới thiệu các thư viện cần thiết​

Một số thư viện hữu ích trong quá trình phát triển ứng dụng:

• http - Gửi yêu cầu HTTP.
• dio - Thư viện HTTP mạnh mẽ với nhiều tính năng nâng cao.
• provider - Quản lý trạng thái đơn giản.
• flutter_bloc - Quản lý trạng thái theo mô hình Bloc.
• firebase_core - Tích hợp Firebase vào ứng dụng.
• google_mlkit - Bộ công cụ Machine Learning của Google dành cho di động.

Cài đặt thư viện bằng cách chỉnh sửa tệp pubspec.yaml hoặc sử dụng lệnh:

flutter pub add http dio provider flutter_bloc firebase_core google_mlkit

5. Bài tập thực hành​

• Tạo một dự án Flutter mới.
• Thiết kế một màn hình đơn giản.
• Kiểm tra log khi chạy ứng dụng bằng print() hoặc debugPrint().

📺 Mời bạn xem video hướng dẫn​

📜 Mời bạn xem Syllabus khoá học​

Xem chi tiết tại Syllabus Flutter.

🚀 Tăng Tốc Phát Triển Ứng Dụng Với Mobile App Framework​

Trong lĩnh vực phát triển ứng dụng, tối ưu hóa quy trình đóng vai trò then chốt giúp sản phẩm nhanh chóng ra mắt thị trường và duy trì lợi thế cạnh tranh. Việc lựa chọn đúng mobile app framework không chỉ giúp rút ngắn thời gian phát triển mà còn nâng cao chất lượng ứng dụng và giảm thiểu chi phí.

Thay vì phải lập trình riêng lẻ cho từng nền tảng (iOS, Android), các framework hiện đại cho phép tái sử dụng mã nguồn, giúp quá trình phát triển ứng dụng trở nên hiệu quả hơn. Dưới đây là một số lựa chọn phổ biến:

Lựa Chọn Framework Phù Hợp​

Việc lựa chọn framework phù hợp phụ thuộc vào yêu cầu cụ thể của dự án:

• Nếu bạn ưu tiên hiệu suất và tính linh hoạt, React Native là một lựa chọn tốt.
• Nếu bạn muốn tạo ra ứng dụng với giao diện đẹp mắt và tốc độ xử lý mượt mà, Flutter sẽ là lựa chọn nổi bật.
• Đối với các dự án nhỏ hoặc cần phát triển nhanh, Hybrid Framework như Ionic có thể là giải pháp tối ưu.

Tại Sao Nên Sử Dụng Framework?​

Sử dụng framework mang lại nhiều lợi ích đáng kể:

• Tiết kiệm thời gian: Mã nguồn có thể tái sử dụng, giảm thiểu công sức coding.
• Tối ưu chi phí: Giảm nhân lực và thời gian phát triển.
• Hỗ trợ cộng đồng mạnh mẽ: Các framework phổ biến như Flutter và React Native có cộng đồng lớn, tài liệu phong phú và hỗ trợ kỹ thuật tốt.

📌 Tìm hiểu thêm về ưu, nhược điểm của từng framework trong phần bình luận bên dưới!

Tags​

#MobileDevelopment #Flutter #ReactNative #AppDevelopment #LậpTrìnhMobile

Giao dịch tự động đang ngày càng phổ biến, giúp các nhà đầu tư loại bỏ yếu tố cảm xúc, tối ưu hóa lợi nhuận và quản lý rủi ro tốt hơn. Bài viết này sẽ hướng dẫn bạn cách xây dựng một bot giao dịch tự động từ TradingView đến Python.

1. Lựa Chọn Chiến Lược Giao Dịch​

Trước khi lập trình bot, bạn cần xác định chiến lược giao dịch phù hợp. Một số chiến lược phổ biến:

• Giao dịch theo xu hướng: Dựa vào các đường MA, RSI, MACD để xác định điểm vào lệnh.
• Giao dịch theo breakout: Mua khi giá vượt qua mức kháng cự quan trọng.
• Giao dịch theo price action: Dựa trên mô hình nến để xác định tín hiệu mua/bán.
• Scalping & Day Trading: Giao dịch nhanh trong ngày để tận dụng biến động nhỏ.

2. Tích Hợp TradingView với Pine Script​

TradingView cho phép tạo tín hiệu giao dịch bằng Pine Script. Ví dụ, mã nguồn đơn giản để xác định tín hiệu giao dịch:

//@version=5
strategy("Simple Moving Average Bot", overlay=true)
short_ma = ta.sma(close, 10)
long_ma = ta.sma(close, 50)

buy_signal = ta.crossover(short_ma, long_ma)
sell_signal = ta.crossunder(short_ma, long_ma)

strategy.entry("Buy", strategy.long, when=buy_signal)
strategy.close("Buy", when=sell_signal)
plot(short_ma, color=color.blue)
plot(long_ma, color=color.red)

Sau khi tạo chiến lược, bạn có thể thiết lập webhook để gửi tín hiệu đến Python.

3. Xây Dựng API Python để Nhận Tín Hiệu​

Dùng Flask để xây dựng API nhận tín hiệu giao dịch:

from flask import Flask, request
import json

app = Flask(__name__)

@app.route("/webhook", methods=["POST"])
def webhook():
    data = request.json
    if data["action"] == "buy":
        print("Mua cổ phiếu!")
    elif data["action"] == "sell":
        print("Bán cổ phiếu!")
    return {"status": "success"}

if __name__ == "__main__":
    app.run(port=5000)

4. Kết Nối API với Sàn Giao Dịch​

Bạn có thể dùng Binance API hoặc một sàn giao dịch khác để đặt lệnh tự động:

from binance.client import Client

api_key = "your_api_key"
api_secret = "your_api_secret"
client = Client(api_key, api_secret)

order = client.order_market_buy(
    symbol='BTCUSDT',
    quantity=0.01
)

5. Giám Sát và Cải Tiến Bot​

Sau khi bot hoạt động, cần theo dõi và cải tiến chiến lược bằng cách:

• Ghi log các giao dịch để phân tích hiệu suất.
• Dùng Telegram Bot để nhận thông báo giao dịch.
• Kiểm tra bot trên dữ liệu lịch sử (backtest) trước khi giao dịch thật.

6. Kết Luận​

Việc xây dựng bot giao dịch tự động giúp bạn giao dịch hiệu quả hơn, giảm thiểu rủi ro và tận dụng cơ hội thị trường nhanh chóng. Bạn có thể mở rộng bot bằng cách tích hợp AI hoặc machine learning để tối ưu chiến lược giao dịch. 🚀

Mô hình ARIMA (AutoRegressive Integrated Moving Average) là một trong những phương pháp phổ biến để dự báo chuỗi thời gian. Trong bài viết này, chúng ta sẽ thực hiện xây dựng mô hình ARIMA để phân tích dữ liệu Close của cổ phiếu.

1️⃣ Cài đặt thư viện cần thiết​

Trước tiên, chúng ta cần cài đặt thư viện statsmodels nếu chưa có:

pip install statsmodels pandas numpy

2️⃣ Xây dựng mô hình ARIMA​

Dưới đây là các bước chính để xây dựng mô hình ARIMA:

from statsmodels.tsa.arima.model import ARIMA
import pandas as pd


# Dữ liệu mẫu (có thể thay thế bằng dữ liệu thực tế)
data = pd.DataFrame({
    'Datetime': ["2025-03-07", "2025-03-10", "2025-03-11", "2025-03-12", "2025-03-13"],
    'Close': [26650.0, 26450.0, 26450.0, 26300.0, 26100.0],
    'High': [26800.0, 26750.0, 26450.0, 26700.0, 26450.0],
    'Low': [26350.0, 26400.0, 26100.0, 26200.0, 26100.0],
    'Open': [26500.0, 26700.0, 26300.0, 26500.0, 26350.0],
    'Volume': [12984900, 11003400, 12961400, 8814301, 13510500]
})

# Bước 1: Khởi tạo & Xây dựng mô hình ARIMA
model = ARIMA(data['Close'], order=(5, 1, 0))  # Ví dụ với tham số (p, d, q)

# Bước 2: Huấn luyện mô hình

print(model_fit.summary())

# In ra tóm tắt mô hình
print(model_fit.summary())

3️⃣ Giải thích các tham số mô hình ARIMA​

Mô hình ARIMA có ba tham số chính (p, d, q):

p (AutoRegressive - AR): Số lượng độ trễ của chuỗi thời gian. d (Differencing - I): Số lần lấy sai phân để làm dừng chuỗi. q (Moving Average - MA): Số bậc của trung bình trượt.

💡 Ví dụ: (5,1,0): Sử dụng 5 độ trễ, lấy sai phân 1 lần, và không có trung bình trượt. (2,1,2): Sử dụng 2 độ trễ, lấy sai phân 1 lần, và 2 bậc trung bình trượt.

📌 Kết luận Mô hình ARIMA là một công cụ mạnh mẽ để dự báo chuỗi thời gian. Tuy nhiên, việc lựa chọn tham số (p, d, q) phù hợp yêu cầu kiểm tra tính dừng của dữ liệu và tinh chỉnh để đạt kết quả tối ưu.

🔥 Ở bài viết tiếp theo, chúng ta sẽ sử dụng ADF Test để kiểm định tính dừng của chuỗi thời gian! 🚀

1. Giới Thiệu​

MetaTrader 5 (MT5) là một nền tảng giao dịch phổ biến hỗ trợ lập trình bot tự động bằng ngôn ngữ MQL5 và Python. Trong bài viết này, chúng ta sẽ xây dựng một robot giao dịch tự động (Auto Trading Bot) bằng Python kết nối với MT5.

2. Cài Đặt Môi Trường​

Trước tiên, cài đặt thư viện MetaTrader5 để kết nối với nền tảng MT5:

pip install MetaTrader5 pandas numpy

3. Kết Nối Python Với MT5​

import MetaTrader5 as mt5

# Kết nối đến MT5
if not mt5.initialize():
    print("Kết nối thất bại!")
    mt5.shutdown()

# Lấy thông tin tài khoản
account_info = mt5.account_info()
print(account_info)

4. Lấy Dữ Liệu Thị Trường​

import pandas as pd
from datetime import datetime

symbol = "EURUSD"

# Lấy dữ liệu nến từ MT5
rates = mt5.copy_rates_from_pos(symbol, mt5.TIMEFRAME_M1, 0, 100)

# Chuyển dữ liệu thành DataFrame
rates_frame = pd.DataFrame(rates)
rates_frame['time'] = pd.to_datetime(rates_frame['time'], unit='s')
print(rates_frame.head())

5. Gửi Lệnh Mua/Bán​

def place_order(symbol, order_type, lot_size, sl=None, tp=None):
    order = {
        "action": mt5.TRADE_ACTION_DEAL,
        "symbol": symbol,
        "volume": lot_size,
        "type": mt5.ORDER_TYPE_BUY if order_type == "buy" else mt5.ORDER_TYPE_SELL,
        "price": mt5.symbol_info_tick(symbol).ask if order_type == "buy" else mt5.symbol_info_tick(symbol).bid,
        "deviation": 10,
        "magic": 0,
        "comment": "Python Bot",
        "type_time": mt5.ORDER_TIME_GTC,
        "type_filling": mt5.ORDER_FILLING_IOC
    }
    if sl:
        order["sl"] = sl
    if tp:
        order["tp"] = tp
    result = mt5.order_send(order)
    return result

# Đặt lệnh mua 0.1 lot EURUSD
place_order("EURUSD", "buy", 0.1)

6. Xây Dựng Chiến Lược Giao Dịch Đơn Giản​

Một chiến lược đơn giản sử dụng Chỉ báo Trung bình Động (SMA):

def moving_average_strategy(symbol, short_window=10, long_window=50):
    rates = mt5.copy_rates_from_pos(symbol, mt5.TIMEFRAME_M1, 0, long_window)
    df = pd.DataFrame(rates)
    df['SMA_Short'] = df['close'].rolling(window=short_window).mean()
    df['SMA_Long'] = df['close'].rolling(window=long_window).mean()
    
    if df['SMA_Short'].iloc[-1] > df['SMA_Long'].iloc[-1]:
        place_order(symbol, "buy", 0.1)
    elif df['SMA_Short'].iloc[-1] < df['SMA_Long'].iloc[-1]:
        place_order(symbol, "sell", 0.1)

# Chạy chiến lược giao dịch
moving_average_strategy("EURUSD")

7. Đóng Lệnh Giao Dịch​

def close_positions(symbol):
    positions = mt5.positions_get(symbol=symbol)
    if positions:
        for pos in positions:
            close_order = {
                "action": mt5.TRADE_ACTION_DEAL,
                "position": pos.ticket,
                "symbol": pos.symbol,
                "volume": pos.volume,
                "type": mt5.ORDER_TYPE_SELL if pos.type == 0 else mt5.ORDER_TYPE_BUY,
                "price": mt5.symbol_info_tick(pos.symbol).bid if pos.type == 0 else mt5.symbol_info_tick(pos.symbol).ask,
                "deviation": 10,
                "magic": 0,
                "comment": "Closing position",
                "type_time": mt5.ORDER_TIME_GTC,
                "type_filling": mt5.ORDER_FILLING_IOC
            }
            mt5.order_send(close_order)

# Đóng tất cả lệnh của EURUSD
close_positions("EURUSD")

8. Đánh Giá Hiệu Suất Giao Dịch​

def analyze_trades():
    history = mt5.history_deals_get(datetime(2024, 1, 1), datetime.now())
    df = pd.DataFrame(list(history), columns=["symbol", "type", "volume", "price", "profit", "time"])
    print(df.groupby("symbol")["profit"].sum())

analyze_trades()

9. Tổng Kết​

Việc xây dựng bot giao dịch tự động với Python trên MT5 giúp bạn có thể giao dịch nhanh chóng và chính xác hơn. Bạn có thể tiếp tục phát triển bot bằng các thuật toán Machine Learning để tối ưu hóa kết quả giao dịch! 🚀