Skip to main content

🐍 Ngày 29- Python hằng ngày 365 ngày - Lưu và Tải Dữ Liệu với JSON – Quản lý To-Do List với json

· 3 min read

Trong ngày này, chúc ta sẽ nâng cấp ứng dụng To-Do List để lưu công việc vào file data.json và tự động tải lại danh sách khi mở ứng dụng. Đây là bước đầu giúp chương trình có tính lưu trữ lâu dài.

🧠 Mục tiêu:​

  • Biết sử dụng json để lưu và tải dữ liệu.
  • Tự động lưu danh sách sau mỗi thay đổi.
  • Tự động tải dữ liệu khi khởi động chương trình.

✍️ Code todo_day29.py​

import json
import os

# --- CẤU TRÚC Dữ LIỆU ---
tasks = []

# --- FILE LƯU TRỨ ---
DATA_FILE = "data.json"

# --- TẢI Dữ LIỆU ---
def load_tasks():
    global tasks
    if os.path.exists(DATA_FILE):
        with open(DATA_FILE, "r", encoding="utf-8") as f:
            tasks = json.load(f)
    else:
        tasks = []

# --- LƯU Dữ LIỆU ---
def save_tasks():
    with open(DATA_FILE, "w", encoding="utf-8") as f:
        json.dump(tasks, f, indent=4, ensure_ascii=False)

# --- CÁC HÀM CHỨC NĂNG ---
def display_menu():
    print("\n----- MENU TO-DO LIST -----")
    print("1. Thêm công việc mới")
    print("2. Xem danh sách công việc")
    print("3. Đánh dấu hoàn thành")
    print("4. Xóa công việc")
    print("5. Thoát")
    print("---------------------------")

def addTask(tasks_list):
    task_name = input("Nhập tên công việc: ")
    tasks_list.append({"name": task_name, "done": False})
    save_tasks()
    print("✅ Đã thêm công việc.")

def viewTasks(tasks_list):
    if not tasks_list:
        print("📬 Không có công việc nào.")
        return
    print("\n📋 DANH SÁCH CÔNG VIỆC:")
    for i, task in enumerate(tasks_list, 1):
        status = "✅" if task["done"] else "❌"
        print(f"{i}. [{status}] {task['name']}")

def markComplete(tasks_list):
    viewTasks(tasks_list)
    try:
        idx = int(input("Nhập số công việc đã hoàn thành: "))
        tasks_list[idx - 1]["done"] = True
        save_tasks()
        print("🎉 Đã đánh dấu hoàn thành.")
    except:
        print("⚠️ Số không hợp lệ.")

def deleteTask(tasks_list):
    viewTasks(tasks_list)
    try:
        idx_del = int(input("Nhập số công việc muốn xóa: "))
        removed = tasks_list.pop(idx_del - 1)
        save_tasks()
        print(f"🗑️ Đã xóa: {removed['name']}")
    except:
        print("⚠️ Không hợp lệ.")

# --- CHẠY CHƯƠNG TRÌNH ---
def main():
    load_tasks()
    while True:
        display_menu()
        choice = input("Chọn (1-5): ")

        if choice == '1':
            addTask(tasks)
        elif choice == '2':
            viewTasks(tasks)
        elif choice == '3':
            markComplete(tasks)
        elif choice == '4':
            deleteTask(tasks)
        elif choice == '5':
            print("👋 Hẹn gặp lại!")
            break
        else:
            print("❌ Lựa chọn không hợp lệ!")

if __name__ == "__main__":
    main()

✅ Kết quả mong đợi​

  • Bạn có thể thêm, xem, đánh dấu hoàn thành hoặc xóa công việc.
  • Khi thoát và mở lại chương trình, danh sách công việc vẫn được giữ nguyên nhờ file data.json.

💪 Thử thách:​

  1. Hiển thị tổng số công việc và số đã hoàn thành.
  2. Thêm ngày tạo cho mỗi công việc.
  3. Tạo file backup_data.json trước khi thóat.

Chúc bạn quản lý công việc ngày một tốt hơn! 🌟

🧠 Ngày 28 – Python Hằng ngày 365 ngày - Hoàn thiện To-Do List App (Phần 2)

· 2 min read

✨ Mục tiêu​

  • Hoàn thiện các chức năng trong app:
    • Thêm công việc mới
    • Xem danh sách công việc
    • Đánh dấu đã hoàn thành
    • Xóa công việc

1. addTask(tasks_list) - Thêm công việc mới​

def addTask(tasks_list):
    print("\n>> Nhập công việc mới:")
    title = input("Tên công việc: ")
    task = {
        "title": title,
        "completed": False
    }
    tasks_list.append(task)
    print("✅ Đã thêm công việc.")

2. viewTasks(tasks_list) - Xem danh sách công việc​

def viewTasks(tasks_list):
    if not tasks_list:
        print("📭 Danh sách công việc trống.")
        return

    print("\n📋 Danh sách công việc:")
    for idx, task in enumerate(tasks_list, start=1):
        status = "✅" if task["completed"] else "⏳"
        print(f"{idx}. {task['title']} [{status}]")

3. markComplete(tasks_list) - Đánh dấu hoàn thành​

def markComplete(tasks_list):
    if not tasks_list:
        print("❌ Không có công việc nào.")
        return

    viewTasks(tasks_list)
    try:
        idx = int(input("Nhập số thứ tự công việc cần đánh dấu hoàn thành: "))
        if 1 <= idx <= len(tasks_list):
            tasks_list[idx-1]["completed"] = True
            print("✅ Công việc đã được đánh dấu hoàn thành.")
        else:
            print("❌ Số không hợp lệ.")
    except ValueError:
        print("⚠️ Vui lòng nhập một số.")

4. deleteTask(tasks_list) - Xóa công việc​

def deleteTask(tasks_list):
    if not tasks_list:
        print("📭 Không có gì để xóa.")
        return

    viewTasks(tasks_list)
    try:
        idx = int(input("Nhập số thứ tự công việc cần xóa: "))
        if 1 <= idx <= len(tasks_list):
            removed = tasks_list.pop(idx-1)
            print(f"🗑️ Đã xóa công việc: {removed['title']}")
        else:
            print("❌ Số không hợp lệ.")
    except ValueError:
        print("⚠️ Vui lòng nhập một số.")

📖 Gợi ý tiếp theo​

  • Ngày 29: Lưu trữ danh sách công việc vào file .json
  • Ngày 30: Đọa luồng menu bằng các module hoặc giao diện

✨ Bạn đã hoàn thành một app console Python có tính tương tác cơ bản! Hãy lưu lại và chia sẻ với bạn bè nếu bạn tự hào nhé! ✨

Các Loại Phương Thức Trong Lớp Python

· 2 min read

🔹 1. Instance Methods – Phương thức của đối tượng​

class Stock:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def update_price(self, new_price):
        self.price = new_price
        print(f"Giá cổ phiếu {self.name} đã cập nhật: {self.price}")

s = Stock("AAPL", 175)
s.update_price(180)

🔹 2. Class Methods – Phương thức của lớp​

class Stock:
    stock_count = 0  

    def __init__(self, name, price):
        self.name = name
        self.price = price
        Stock.stock_count += 1

    @classmethod
    def get_stock_count(cls):
        return cls.stock_count

s1 = Stock("AAPL", 175)
s2 = Stock("TSLA", 720)

print("Tổng số cổ phiếu:", Stock.get_stock_count())

🔹 3. Static Methods – Phương thức tĩnh​

class Stock:
    @staticmethod
    def is_trading_hour(hour):
        return 9 <= hour <= 16

print(Stock.is_trading_hour(14))  # True
print(Stock.is_trading_hour(20))  # False

🔹 4. Dunder Methods – Phương thức đặc biệt​

class Stock:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def __str__(self):
        return f"Cổ phiếu {self.name} có giá {self.price}"

    def __repr__(self):
        return f"Stock('{self.name}', {self.price})"

s = Stock("AAPL", 175)
print(s)   # __str__()
print(repr(s))  # __repr__()

📌 Tổng kết​

Loại phương thứcDecoratorDùng để làm gì?
Instance MethodKhông cóLàm việc với từng đối tượng
Class Method@classmethodLàm việc với lớp (dùng cls)
Static Method@staticmethodHàm thông thường trong lớp
Dunder Method__init__, __str__, __add__...Tùy chỉnh hành vi

Common Functions trong Dự Án Phân Tích Định Lượng

· 2 min read

Trong một dự án phân tích định lượng, việc xây dựng các hàm dùng chung giúp tiết kiệm thời gian và chuẩn hóa quy trình xử lý dữ liệu, phân tích và giao dịch. Dưới đây là một số nhóm hàm quan trọng.

1. Xử Lý Dữ Liệu​

import pandas as pd
import numpy as np

def clean_data(df):
    """Làm sạch dữ liệu: loại bỏ giá trị NaN, trùng lặp."""
    df = df.drop_duplicates()
    df = df.dropna()
    return df

def normalize_data(df, columns):
    """Chuẩn hóa dữ liệu theo min-max scaling."""
    for col in columns:
        df[col] = (df[col] - df[col].min()) / (df[col].max() - df[col].min())
    return df

2. Tải Dữ Liệu từ API​

import yfinance as yf

def get_stock_data(ticker, start, end):
    """Tải dữ liệu giá cổ phiếu từ Yahoo Finance."""
    stock = yf.download(ticker, start=start, end=end)
    return stock

3. Tính Toán Thống Kê Cơ Bản​

def moving_average(data, window):
    """Tính trung bình động (Moving Average)"""
    return data.rolling(window=window).mean()

def calculate_correlation(df, col1, col2):
    """Tính hệ số tương quan giữa hai cột."""
    return df[col1].corr(df[col2])

4. Backtesting Chiến Lược Giao Dịch​

def backtest_strategy(prices, signals):
    """Đánh giá hiệu suất chiến lược giao dịch."""
    returns = prices.pct_change() * signals.shift(1)
    return returns.cumsum()

5. Hiển Thị Dữ Liệu​

import matplotlib.pyplot as plt

def plot_stock_prices(df, ticker):
    """Vẽ biểu đồ giá cổ phiếu."""
    plt.figure(figsize=(10, 5))
    plt.plot(df['Close'], label=f'{ticker} Close Price')
    plt.title(f'Giá Cổ Phiếu {ticker}')
    plt.xlabel('Thời Gian')
    plt.ylabel('Giá')
    plt.legend()
    plt.show()

Kết Luận​

Bộ hàm trên giúp chuẩn hóa quy trình phân tích định lượng, từ việc xử lý dữ liệu, tải dữ liệu, tính toán thống kê đến backtesting chiến lược. Tích hợp các hàm này vào dự án sẽ giúp bạn làm việc hiệu quả hơn.

Hàm Trong Lớp Python - Phương Thức Trong OOP

· 3 min read

Trong lập trình hướng đối tượng (OOP) của Python, hàm trong lớp (hay phương thức - method) là các hàm được định nghĩa bên trong một lớp và có thể thao tác với các thuộc tính của lớp đó.

1. Các Loại Hàm Trong Lớp​

Python hỗ trợ ba loại phương thức chính trong một lớp:

1.1. Instance Method​

  • Là phương thức phổ biến nhất, có thể truy cập và thay đổi thuộc tính của từng đối tượng.
  • Cần có tham số self để tham chiếu đến chính đối tượng.

Ví dụ:​

class NhanVien:
    def __init__(self, ten, luong):
        self.ten = ten
        self.luong = luong

    def hien_thi_thong_tin(self):
        return f"Nhân viên: {self.ten}, Lương: {self.luong} VND"

nv = NhanVien("Hà", 15000000)
print(nv.hien_thi_thong_tin())

1.2. Class Method​

  • Được sử dụng khi muốn làm việc với biến của lớp thay vì từng đối tượng riêng lẻ.
  • Sử dụng decorator @classmethod và tham số cls.

Ví dụ:​

class CongTy:
    so_nhan_vien = 0

    def __init__(self, ten):
        self.ten = ten
        CongTy.so_nhan_vien += 1

    @classmethod
    def tong_nhan_vien(cls):
        return f"Tổng số nhân viên: {cls.so_nhan_vien}"

# Tạo nhân viên mới
nv1 = CongTy("Hà")
nv2 = CongTy("Nam")

print(CongTy.tong_nhan_vien())

1.3. Static Method​

  • Là phương thức độc lập, không truy cập thuộc tính của lớp hay đối tượng.
  • Dùng @staticmethod để định nghĩa.

Ví dụ:​

class TinhToan:
    @staticmethod
    def cong(a, b):
        return a + b

print(TinhToan.cong(10, 20))

2. Ứng Dụng Thực Tế Của Hàm Trong Lớp​

Dưới đây là ví dụ về một hệ thống quản lý giao dịch tài chính sử dụng OOP:

class TaiKhoanNganHang:
    lai_suat = 0.03  # Biến lớp

    def __init__(self, so_tk, so_du):
        self.so_tk = so_tk
        self.so_du = so_du

    def gui_tien(self, so_tien):
        self.so_du += so_tien
        return f"Đã gửi {so_tien} VND. Số dư mới: {self.so_du} VND"

    @classmethod
    def thay_doi_lai_suat(cls, lai_suat_moi):
        cls.lai_suat = lai_suat_moi
        return f"Lãi suất mới: {cls.lai_suat * 100}%"

    @staticmethod
    def kiem_tra_so_tk(so_tk):
        return len(str(so_tk)) == 10

# Tạo tài khoản
tk1 = TaiKhoanNganHang(1234567890, 5000000)

# Gửi tiền
print(tk1.gui_tien(2000000))

# Thay đổi lãi suất
print(TaiKhoanNganHang.thay_doi_lai_suat(0.05))

# Kiểm tra số tài khoản hợp lệ
print(TaiKhoanNganHang.kiem_tra_so_tk(1234567890))

Kết Luận​

  • Instance Method thường dùng để làm việc với thuộc tính của từng đối tượng.
  • Class Method dùng để làm việc với biến của lớp.
  • Static Method không liên quan đến dữ liệu của lớp hoặc đối tượng, chỉ chứa logic độc lập.

Hy vọng bài viết này giúp bạn hiểu rõ hơn về phương thức trong Python OOP! 🚀

Hàm trong Python - Hướng dẫn chi tiết cho người mới

· 2 min read

1️⃣ Hàm trong Python là gì?​

Hàm là một khối mã có thể tái sử dụng để thực hiện một tác vụ cụ thể. Hàm giúp code dễ đọc, dễ bảo trì và giảm lặp lại.

2️⃣ Cách định nghĩa và gọi hàm​

📝 Cú pháp định nghĩa hàm:​

def ten_ham(tham_so_1, tham_so_2):
    # Khối lệnh của hàm
    return gia_tri_tra_ve

🚀 Ví dụ:​

def tong(a, b):
    return a + b

print(tong(3, 5))  # Output: 8

3️⃣ Tham số và Giá trị trả về​

  • Tham số mặc định: Nếu không truyền giá trị, Python sẽ sử dụng giá trị mặc định.
def xin_chao(ten="Bạn"):
    print(f"Xin chào, {ten}!")

xin_chao()       # Xin chào, Bạn!
xin_chao("Vinh") # Xin chào, Vinh!
  • Hàm có nhiều giá trị trả về: Trả về tuple.
def tinh_toan(a, b):
    return a + b, a * b

tong, tich = tinh_toan(4, 5)
print(tong, tich)  # Output: 9 20

4️⃣ Hàm Lambda (Hàm ẩn danh)​

Hàm Lambda là hàm nhỏ gọn, có thể viết trong một dòng.

binh_phuong = lambda x: x**2
print(binh_phuong(6))  # Output: 36

5️⃣ Ứng dụng thực tế​

🔹 Tính tổng danh sách số:

def tinh_tong_danh_sach(danh_sach):
    return sum(danh_sach)

print(tinh_tong_danh_sach([1, 2, 3, 4]))  # Output: 10

🔹 Lọc số chẵn từ danh sách bằng Lambda:

danh_sach = [1, 2, 3, 4, 5, 6]
so_chan = list(filter(lambda x: x % 2 == 0, danh_sach))
print(so_chan)  # Output: [2, 4, 6]

🔥 Kết luận​

Hàm trong Python giúp tổ chức code tốt hơn, tái sử dụng dễ dàng và viết chương trình hiệu quả hơn. Bắt đầu sử dụng hàm ngay để nâng cao kỹ năng lập trình của bạn!

📌 Xem thêm:

Hệ Thống Phân Tích Định Lượng Trong Giao Dịch Tự Động

· 3 min read

1. Xử Lý Dữ Liệu Tài Chính​

Trước khi phân tích hoặc xây dựng mô hình, ta cần làm sạch và chuẩn hóa dữ liệu:

  • Loại bỏ dữ liệu trùng lặp, thiếu, hoặc ngoại lệ.
  • Tính toán các chỉ số như đường trung bình động (MA), RSI, Bollinger Bands.
  • Chuyển đổi dữ liệu thời gian về dạng chuẩn.

Ví dụ xử lý dữ liệu với pandas:

import pandas as pd

# Đọc dữ liệu từ CSV
df = pd.read_csv("stock_data.csv")

# Xử lý giá trị thiếu
df.fillna(method='ffill', inplace=True)

# Tính đường trung bình động 20 ngày
df['MA20'] = df['Close'].rolling(window=20).mean()

print(df.head())

2. Tích Hợp API Tài Chính​

Chúng ta có thể sử dụng yfinance, Alpha Vantage, hoặc Binance API để lấy dữ liệu.

Ví dụ với yfinance:

import yfinance as yf

# Tải dữ liệu cổ phiếu Apple
data = yf.download("AAPL", start="2023-01-01", end="2024-01-01")

print(data.head())

3. Các Chiến Lược Giao Dịch Phổ Biến​

3.1. Mean Reversion​

Dựa trên giả thuyết rằng giá sẽ quay về giá trị trung bình.

df['Signal'] = 0
df.loc[df['Close'] < df['MA20'], 'Signal'] = 1  # Mua khi giá thấp hơn MA20
df.loc[df['Close'] > df['MA20'], 'Signal'] = -1  # Bán khi giá cao hơn MA20

3.2. Momentum Trading​

Mua khi xu hướng mạnh lên, bán khi xu hướng yếu đi.

df['Momentum'] = df['Close'].pct_change(periods=5)
df['Signal'] = df['Momentum'].apply(lambda x: 1 if x > 0 else -1)

4. Tối Ưu Hóa Chiến Lược Giao Dịch​

  • Backtesting: Kiểm tra hiệu suất chiến lược dựa trên dữ liệu quá khứ.
  • Walk-forward optimization: Tối ưu tham số qua từng giai đoạn.
  • Risk Management: Sử dụng Stop-Loss, Take-Profit hợp lý.

Ví dụ backtest đơn giản:

initial_capital = 10000
df['Returns'] = df['Signal'].shift(1) * df['Close'].pct_change()
df['Equity'] = initial_capital * (1 + df['Returns']).cumprod()

print(df[['Close', 'Equity']].tail())

5. Triển Khai Mô Hình Machine Learning​

5.1. Dự Đoán Giá với Hồi Quy Tuyến Tính​

from sklearn.linear_model import LinearRegression
import numpy as np

df['Future_Close'] = df['Close'].shift(-5)  # Dự đoán giá sau 5 ngày
X = np.array(df[['Open', 'High', 'Low', 'Close']].dropna())
y = np.array(df['Future_Close'].dropna())

model = LinearRegression()
model.fit(X[:-5], y[:-5])  # Loại bỏ 5 ngày cuối

predicted_price = model.predict(X[-5:])
print(predicted_price)

5.2. Sử Dụng LSTM Để Dự Đoán Giá​

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

model = Sequential([
    LSTM(50, return_sequences=True, input_shape=(X.shape[1], 1)),
    LSTM(50),
    Dense(1)
])

model.compile(optimizer='adam', loss='mse')

Kết Luận​

Bài viết này đã giới thiệu các bước cơ bản để xây dựng hệ thống phân tích định lượng cho giao dịch tự động. Bạn có thể mở rộng bằng cách kết hợp thêm AI, tối ưu hóa chiến lược, và tích hợp hệ thống thực chiến. 🚀

Kết Nối Python Với Power BI

· 2 min read

📌 Giới Thiệu​

Power BI là một công cụ mạnh mẽ giúp trực quan hóa và phân tích dữ liệu. Việc tích hợp Python với Power BI giúp mở rộng khả năng xử lý, làm sạch dữ liệu và tạo các mô hình phân tích nâng cao. Bài viết này sẽ hướng dẫn bạn cách kết nối Python với Power BI và thực hiện các phân tích cơ bản.

🧑‍💻 Cài Đặt Môi Trường​

Trước khi bắt đầu, bạn cần cài đặt:

  • Python (3.8 trở lên)
  • Các thư viện cần thiết: Pandas, Matplotlib, Seaborn
  • Power BI Desktop

Cài đặt thư viện Python:

pip install pandas matplotlib seaborn

🔗 Kết Nối Python Với Power BI​

  1. Mở Power BI Desktop, vào File > Options and settings > Options.
  2. Chọn Python scripting, trỏ đường dẫn đến thư mục Python đã cài đặt.
  3. Vào Home > Transform data để mở Power Query Editor.
  4. Chọn Run Python script và nhập code Python.

Ví dụ đơn giản:

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

# Giả sử 'dataset' là DataFrame được Power BI cung cấp
sns.pairplot(dataset)
plt.show()

🎯 Ứng Dụng​

  • Làm sạch dữ liệu: Xử lý giá trị thiếu, chuẩn hóa dữ liệu.
  • Phân tích nâng cao: Tạo mô hình dự đoán, phân cụm.
  • Trực quan hóa: Dùng Matplotlib, Seaborn để tạo biểu đồ tùy chỉnh.

Kết hợp Python và Power BI giúp bạn tận dụng sức mạnh của cả hai công cụ, nâng cao khả năng phân tích và trực quan hóa dữ liệu. 🚀

Xây dựng Module Chung Cho Phân Tích Định Lượng

· 3 min read

📌 Giới thiệu​

Trong giao dịch định lượng (quantitative trading), việc có một module chung giúp tái sử dụng code, giảm lỗi và tăng hiệu suất là rất quan trọng. Module này có thể bao gồm các chức năng như:

  • Lấy dữ liệu tài chính từ nhiều nguồn (Yahoo Finance, Binance API, Alpha Vantage, etc.)
  • Tiền xử lý dữ liệu (Xử lý thiếu dữ liệu, chuẩn hóa, tạo đặc trưng)
  • Tính toán chỉ báo kỹ thuật (SMA, EMA, RSI, MACD, Bollinger Bands)
  • Thực hiện backtesting chiến lược giao dịch
  • Tối ưu và đánh giá mô hình giao dịch

🏗️ Thiết Kế Module​

1️⃣ Cấu trúc thư mục dự án​

Một dự án phân tích định lượng thường có cấu trúc như sau:

quant_trading_project/
│── data/                  # Chứa dữ liệu tài chính  
│── common/                # Module chung  
│   ├── data_loader.py     # Lấy dữ liệu từ API  
│   ├── indicators.py      # Tính toán các chỉ báo kỹ thuật  
│   ├── utils.py           # Các hàm tiện ích (helpers)  
│── strategies/            # Chiến lược giao dịch  
│── backtesting/           # Kiểm tra hiệu suất giao dịch  
│── main.py                # Chương trình chính  
│── requirements.txt       # Danh sách thư viện

2️⃣ Module data_loader.py – Lấy dữ liệu tài chính​

import yfinance as yf
import pandas as pd

def get_stock_data(symbol, start="2023-01-01", end="2024-01-01"):
    """Lấy dữ liệu giá cổ phiếu từ Yahoo Finance"""
    data = yf.download(symbol, start=start, end=end)
    return data

# Ví dụ sử dụng
if __name__ == "__main__":
    df = get_stock_data("AAPL")
    print(df.head())

3️⃣ Module indicators.py – Tính toán các chỉ báo kỹ thuật​

import pandas as pd

def calculate_sma(data, window=20):
    """Tính đường trung bình động SMA"""
    return data["Close"].rolling(window=window).mean()

def calculate_rsi(data, window=14):
    """Tính RSI (Relative Strength Index)"""
    delta = data["Close"].diff(1)
    gain = (delta.where(delta > 0, 0)).rolling(window=window).mean()
    loss = (-delta.where(delta < 0, 0)).rolling(window=window).mean()
    rs = gain / loss
    return 100 - (100 / (1 + rs))

# Ví dụ sử dụng
if __name__ == "__main__":
    df = get_stock_data("AAPL")
    df["SMA20"] = calculate_sma(df, window=20)
    df["RSI14"] = calculate_rsi(df, window=14)
    print(df.tail())

4️⃣ Module utils.py – Các hàm tiện ích chung​

import numpy as np

def normalize_data(series):
    """Chuẩn hóa dữ liệu về khoảng [0, 1]"""
    return (series - series.min()) / (series.max() - series.min())

def log_return(series):
    """Tính log return của giá đóng cửa"""
    return np.log(series / series.shift(1))

# Ví dụ sử dụng
if __name__ == "__main__":
    df = get_stock_data("AAPL")
    df["Normalized Close"] = normalize_data(df["Close"])
    df["Log Return"] = log_return(df["Close"])
    print(df.head())

✅ Kết Luận​

Module chung giúp tối ưu hóa quá trình phân tích định lượng bằng cách:
✔ Tự động hóa việc lấy dữ liệu
✔ Tính toán các chỉ báo kỹ thuật một cách hiệu quả
✔ Cung cấp các hàm tiện ích giúp tiền xử lý dữ liệu nhanh chóng

Module này có thể dễ dàng mở rộng bằng cách thêm các chỉ báo khác, hoặc tích hợp vào hệ thống giao dịch tự động. 🚀

Tại sao nên học Python? 10 lý do bạn không thể bỏ qua

· 3 min read

1. Python là gì? Tại sao Python lại phổ biến đến vậy?​

Python là một ngôn ngữ lập trình mạnh mẽ, dễ học và được sử dụng rộng rãi trong nhiều lĩnh vực như web, khoa học dữ liệu, trí tuệ nhân tạo, và tự động hóa.

2. 10 lý do nên học Python​

  1. Dễ học: Cú pháp đơn giản, dễ đọc.
  2. Đa dụng: Dùng cho web, AI, tài chính, tự động hóa...
  3. Cộng đồng lớn: Nhiều tài liệu, hỗ trợ tốt.
  4. Thư viện phong phú: Pandas, NumPy, TensorFlow, Flask…
  5. Tích hợp dễ dàng: Kết hợp với C, Java, JS dễ dàng.
  6. Hiệu suất cao: Dù không nhanh như C++, nhưng tối ưu tốt với Cython, Numba.
  7. Được sử dụng bởi các công ty lớn: Google, Facebook, Netflix, Tesla đều dùng Python.
  8. Phát triển nhanh chóng: Có thể viết MVP (Minimum Viable Product) nhanh chóng.
  9. Hỗ trợ tốt cho AI & Machine Learning: Là nền tảng chính của AI hiện nay.
  10. Cơ hội việc làm lớn: Nhiều công ty tuyển dụng lập trình viên Python với mức lương hấp dẫn.

3. Python vs. Ngôn ngữ khác​

Tiêu chíPythonJavaC++JavaScript
Dễ học✅❌❌✅
Đa nền tảng✅✅✅✅
Ứng dụng rộng✅✅✅✅

4. Lộ trình học Python​

  1. Học cú pháp cơ bản: Biến, vòng lặp, điều kiện.
  2. Làm bài tập nhỏ: Viết script tự động hóa đơn giản.
  3. Xây dựng dự án: Web, AI, tự động hóa...

5. Python có khó không?​

  • Nếu học 1-2 giờ/ngày: 2-3 tháng để nắm cơ bản.
  • Nếu muốn chuyên sâu (Web, AI...): 6 tháng - 1 năm.

6. Nghề nghiệp với Python​

  • Web Developer (Django, Flask)
  • Data Scientist (Pandas, NumPy, Scikit-learn)
  • AI Engineer (TensorFlow, PyTorch)
  • DevOps Engineer (Automate, Ansible)

7. Lộ trình trở thành Web Developer với Python​

  1. Học HTML, CSS, JavaScript.
  2. Học Flask hoặc Django.
  3. Xây dựng API RESTful.

8. Python trong Data Science​

  1. Xử lý dữ liệu: Pandas, NumPy
  2. Trực quan hóa: Matplotlib, Seaborn
  3. Machine Learning: Scikit-learn, TensorFlow

9. Python trong tài chính​

  • Phân tích dữ liệu tài chính với Pandas.
  • Giao dịch tự động với API (Binance, Alpaca).
  • Tối ưu hóa danh mục đầu tư với Machine Learning.

10. Python và tự động hóa​

  1. Tự động hóa công việc văn phòng (Excel, Google Sheets).
  2. Web Scraping: BeautifulSoup, Selenium.
  3. Tự động hóa DevOps: Ansible, Docker.