Binance API Lấy Dữ Liệu K-line Lịch Sử Bằng Python — Hướng Dẫn Toàn Diện 2026

Kết luận ngắn: Bài viết này cung cấp code Python hoàn chỉnh để fetch dữ liệu nến (K-line) từ Binance API với độ trễ thực tế dưới 100ms, chi phí hoàn toàn miễn phí khi dùng API chính thức. Nếu bạn cần xử lý AI để phân tích dữ liệu này, HolySheep AI là lựa chọn tiết kiệm 85%+ với tín dụng miễn phí khi đăng ký.

Tổng Quan Về Binance K-line API

Dữ liệu K-line (candlestick) là nền tảng của mọi chiến lược giao dịch tiền mã hóa. Binance cung cấp API miễn phí với giới hạn 1200 request/phút cho endpoint kline, đủ cho hầu hết use case cá nhân và backtest.

Ưu điểm của Binance API chính thức

Hoàn toàn miễn phí — không tốn chi phí API
Độ trễ thực tế: 50-150ms tùy khu vực
Hỗ trợ tất cả cặp giao dịch và khung thời gian
Không cần API key cho dữ liệu public

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

Trước khi bắt đầu, hãy cài đặt các thư viện cần thiết. Thời gian cài đặt trên môi trường sạch khoảng 30-60 giây.

# Cài đặt thư viện cần thiết
pip install requests pandas python-dotenv

Kiểm tra phiên bản Python (yêu cầu >= 3.8)
python --version

Tạo file .env để lưu API keys (nếu cần)
touch .env
echo "BINANCE_API_KEY=your_api_key_here" >> .env
echo "BINANCE_SECRET_KEY=your_secret_key_here" >> .env

Code Python Hoàn Chỉnh

1. Lấy Dữ Liệu K-line Cơ Bản

import requests
import pandas as pd
from datetime import datetime
import time

class BinanceKlineFetcher:
    """Class lấy dữ liệu K-line từ Binance API"""
    
    BASE_URL = "https://api.binance.com/api/v3"
    
    def __init__(self):
        self.session = requests.Session()
        self.session.headers.update({
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        })
    
    def get_klines(self, symbol: str, interval: str, limit: int = 500) -> pd.DataFrame:
        """
        Lấy dữ liệu K-line
        
        Args:
            symbol: Cặp giao dịch (VD: 'BTCUSDT')
            interval: Khung thời gian ('1m', '5m', '1h', '1d'...)
            limit: Số lượng nến (max 1000)
        
        Returns:
            DataFrame với dữ liệu K-line
        """
        endpoint = f"{self.BASE_URL}/klines"
        params = {
            'symbol': symbol.upper(),
            'interval': interval,
            'limit': limit
        }
        
        start_time = time.time()
        response = self.session.get(endpoint, params=params, timeout=10)
        latency_ms = (time.time() - start_time) * 1000
        
        print(f"📡 Request completed in {latency_ms:.2f}ms")
        
        if response.status_code != 200:
            raise Exception(f"API Error: {response.status_code} - {response.text}")
        
        data = response.json()
        
        # Định nghĩa columns theo tài liệu Binance
        columns = [
            'open_time', 'open', 'high', 'low', 'close', 'volume',
            'close_time', 'quote_volume', 'trades', 'taker_buy_base',
            'taker_buy_quote', 'ignore'
        ]
        
        df = pd.DataFrame(data, columns=columns)
        
        # Chuyển đổi kiểu dữ liệu
        numeric_cols = ['open', 'high', 'low', 'close', 'volume', 'quote_volume']
        for col in numeric_cols:
            df[col] = pd.to_numeric(df[col])
        
        # Chuyển timestamp sang datetime
        df['open_time'] = pd.to_datetime(df['open_time'], unit='ms')
        df['close_time'] = pd.to_datetime(df['close_time'], unit='ms')
        
        return df
    
    def get_historical_klines(self, symbol: str, interval: str, 
                               start_time: int, end_time: int = None) -> pd.DataFrame:
        """
        Lấy dữ liệu K-line trong khoảng thời gian cụ thể
        
        Args:
            symbol: Cặp giao dịch
            interval: Khung thời gian
            start_time: Timestamp bắt đầu (milisecond)
            end_time: Timestamp kết thúc (milisecond)
        """
        endpoint = f"{self.BASE_URL}/klines"
        all_klines = []
        
        params = {
            'symbol': symbol.upper(),
            'interval': interval,
            'startTime': start_time,
            'limit': 1000
        }
        
        if end_time:
            params['endTime'] = end_time
        
        while True:
            response = self.session.get(endpoint, params=params, timeout=10)
            
            if response.status_code != 200:
                raise Exception(f"API Error: {response.status_code}")
            
            data = response.json()
            
            if not data:
                break
            
            all_klines.extend(data)
            
            # Cập nhật startTime để lấy batch tiếp theo
            last_open_time = int(data[-1][0])
            params['startTime'] = last_open_time + 1
            
            print(f"✅ Fetched {len(data)} klines, last timestamp: {last_open_time}")
            
            # Tránh rate limit
            time.sleep(0.2)
        
        # Chuyển đổi sang DataFrame
        columns = [
            'open_time', 'open', 'high', 'low', 'close', 'volume',
            'close_time', 'quote_volume', 'trades', 'taker_buy_base',
            'taker_buy_quote', 'ignore'
        ]
        
        df = pd.DataFrame(all_klines, columns=columns)
        
        numeric_cols = ['open', 'high', 'low', 'close', 'volume', 'quote_volume']
        for col in numeric_cols:
            df[col] = pd.to_numeric(df[col])
        
        df['open_time'] = pd.to_datetime(df['open_time'], unit='ms')
        df['close_time'] = pd.to_datetime(df['close_time'], unit='ms')
        
        return df


Sử dụng
if __name__ == "__main__":
    fetcher = BinanceKlineFetcher()
    
    # Lấy 500 nến 1 giờ gần nhất của BTCUSDT
    print("=" * 50)
    print("Lấy dữ liệu BTCUSDT 1h gần nhất")
    print("=" * 50)
    
    df = fetcher.get_klines('BTCUSDT', '1h', limit=500)
    print(f"\n📊 Data shape: {df.shape}")
    print(f"📅 Date range: {df['open_time'].min()} to {df['open_time'].max()}")
    print(f"\n{df.head()}")
    
    # Lưu vào CSV
    df.to_csv('btcusdt_1h.csv', index=False)
    print("\n💾 Đã lưu vào btcusdt_1h.csv")

2. Code Nâng Cao với Async và Rate Limit Handling

import asyncio
import aiohttp
import pandas as pd
from typing import List, Dict, Optional
from datetime import datetime, timedelta
import time

class AsyncBinanceKlineFetcher:
    """Async fetcher cho high-performance trading systems"""
    
    BASE_URL = "https://api.binance.com/api/v3"
    RATE_LIMIT = 1200  # requests per minute
    REQUEST_INTERVAL = 60 / RATE_LIMIT  # seconds between requests
    
    def __init__(self):
        self.last_request_time = 0
        self.request_count = 0
        self.session: Optional[aiohttp.ClientSession] = None
    
    async def __aenter__(self):
        self.session = aiohttp.ClientSession()
        return self
    
    async def __aexit__(self, *args):
        if self.session:
            await self.session.close()
    
    async def _throttled_request(self, url: str, params: Dict) -> Dict:
        """Request với rate limit handling"""
        current_time = time.time()
        time_since_last = current_time - self.last_request_time
        
        if time_since_last < self.REQUEST_INTERVAL:
            await asyncio.sleep(self.REQUEST_INTERVAL - time_since_last)
        
        self.last_request_time = time.time()
        
        async with self.session.get(url, params=params) as response:
            if response.status == 429:
                # Rate limit exceeded - wait and retry
                retry_after = int(response.headers.get('Retry-After', 60))
                print(f"⚠️ Rate limit hit, waiting {retry_after}s")
                await asyncio.sleep(retry_after)
                return await self._throttled_request(url, params)
            
            data = await response.json()
            return data
    
    async def get_klines_batch(self, symbols: List[str], interval: str, 
                                limit: int = 500) -> Dict[str, pd.DataFrame]:
        """Lấy dữ liệu nhiều cặp giao dịch song song"""
        results = {}
        tasks = []
        
        for symbol in symbols:
            task = self._fetch_single(symbol, interval, limit)
            tasks.append(task)
        
        # Execute all tasks with semaphore to limit concurrency
        semaphore = asyncio.Semaphore(5)  # Max 5 concurrent requests
        
        async def bounded_fetch(task):
            async with semaphore:
                return await task
        
        bounded_tasks = [bounded_fetch(t) for t in tasks]
        results_list = await asyncio.gather(*bounded_tasks, return_exceptions=True)
        
        for symbol, result in zip(symbols, results_list):
            if isinstance(result, Exception):
                print(f"❌ Error fetching {symbol}: {result}")
                results[symbol] = None
            else:
                results[symbol] = result
        
        return results
    
    async def _fetch_single(self, symbol: str, interval: str, limit: int) -> pd.DataFrame:
        """Fetch single symbol"""
        url = f"{self.BASE_URL}/klines"
        params = {'symbol': symbol.upper(), 'interval': interval, 'limit': limit}
        
        start = time.time()
        data = await self._throttled_request(url, params)
        latency_ms = (time.time() - start) * 1000
        
        print(f"✅ {symbol}: fetched in {latency_ms:.2f}ms")
        
        columns = [
            'open_time', 'open', 'high', 'low', 'close', 'volume',
            'close_time', 'quote_volume', 'trades', 'taker_buy_base',
            'taker_buy_quote', 'ignore'
        ]
        
        df = pd.DataFrame(data, columns=columns)
        
        numeric_cols = ['open', 'high', 'low', 'close', 'volume', 'quote_volume']
        for col in numeric_cols:
            df[col] = pd.to_numeric(df[col])
        
        df['open_time'] = pd.to_datetime(df['open_time'], unit='ms')
        
        return df
    
    def calculate_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
        """Tính toán các chỉ báo kỹ thuật"""
        # RSI
        delta = df['close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
        rs = gain / loss
        df['rsi'] = 100 - (100 / (1 + rs))
        
        # SMA
        df['sma_20'] = df['close'].rolling(window=20).mean()
        df['sma_50'] = df['close'].rolling(window=50).mean()
        
        # Bollinger Bands
        df['bb_middle'] = df['close'].rolling(window=20).mean()
        bb_std = df['close'].rolling(window=20).std()
        df['bb_upper'] = df['bb_middle'] + (bb_std * 2)
        df['bb_lower'] = df['bb_middle'] - (bb_std * 2)
        
        return df


Sử dụng async version
async def main():
    symbols = ['BTCUSDT', 'ETHUSDT', 'BNBUSDT', 'SOLUSDT', 'ADAUSDT']
    
    async with AsyncBinanceKlineFetcher() as fetcher:
        print("🚀 Fetching multiple symbols concurrently...")
        
        results = await fetcher.get_klines_batch(symbols, '1h', limit=100)
        
        for symbol, df in results.items():
            if df is not None:
                df_with_indicators = fetcher.calculate_indicators(df)
                print(f"\n📊 {symbol} - Latest RSI: {df_with_indicators['rsi'].iloc[-1]:.2f}")
                print(f"   SMA20: ${df_with_indicators['sma_20'].iloc[-1]:,.2f}")
                print(f"   SMA50: ${df_with_indicators['sma_50'].iloc[-1]:,.2f}")


if __name__ == "__main__":
    asyncio.run(main())

So Sánh Giải Pháp Lấy Dữ Liệu Crypto

Tiêu chí	Binance API (chính thức)	HolySheep AI	CCXT Library	Kaiko / CoinMetrics
Chi phí	Miễn phí	¥1 = $1 (tiết kiệm 85%+)	Miễn phí	$500+/tháng
Độ trễ	50-150ms	<50ms	100-300ms	20-50ms
Phương thức thanh toán	Không áp dụng	WeChat, Alipay, Visa	Không áp dụng	Thẻ tín dụng, wire
Loại dữ liệu	K-line, trades, depth	AI analysis	Tất cả exchange	Tick data, orderbook
Giới hạn request	1200/phút	Unlimited	Tùy exchange	Unlimited
Độ phủ	Chỉ Binance	300+ LLMs	100+ exchanges	30+ exchanges
Phù hợp cho	Backtest, trading bot	AI analysis, automation	Multi-exchange	Institution

Phù Hợp / Không Phù Hợp Với Ai

✅ Nên dùng Binance API khi:

Bạn cần dữ liệu K-line miễn phí cho backtest
Viết trading bot cá nhân
Cần historical data từ 2017 đến nay
Khối lượng request dưới 1200/phút

❌ Không nên dùng khi:

Cần real-time data với độ trễ dưới 20ms
Cần dữ liệu từ nhiều exchange cùng lúc
Cần AI để phân tích dữ liệu
Use case institutional với SLA cao

Giá Và ROI

Giải pháp	Giá tháng	Tín dụng miễn phí	ROI cho retail trader
Binance API	$0	$0	✅ Tối ưu
HolySheep AI	Từ ¥68/tháng	Có, khi đăng ký	✅ Tốt cho AI tasks
Kaiko	$500+	Không	❌ Chỉ institution
CoinAPI	$79+	Có trial	⚠️ Trung bình

Vì Sao Chọn HolySheep AI

Khi bạn đã có dữ liệu K-line từ Binance API, bước tiếp theo thường là phân tích bằng AI. Đây là lúc HolySheep AI phát huy thế mạnh:

Tiết kiệm 85%: Tỷ giá ¥1=$1, so với OpenAI $8/1M tokens
Tốc độ <50ms: Nhanh hơn hầu hết đối thủ
Thanh toán linh hoạt: WeChat, Alipay, Visa — thuận tiện cho người Việt
Tín dụng miễn phí: Đăng ký ngay tại HolySheep AI

Lỗi Thường Gặp Và Cách Khắc Phục

Lỗi 1: HTTP 429 - Rate Limit Exceeded

# ❌ Lỗi thường gặp
Binance API trả về 429 khi vượt quá giới hạn request

✅ Giải pháp 1: Thêm delay giữa các request
import time
import requests

def safe_request(url, params, max_retries=3):
    for attempt in range(max_retries):
        response = requests.get(url, params=params)
        
        if response.status_code == 429:
            retry_after = int(response.headers.get('Retry-After', 60))
            print(f"Rate limit hit, waiting {retry_after}s...")
            time.sleep(retry_after)
        elif response.status_code == 200:
            return response.json()
        else:
            raise Exception(f"HTTP {response.status_code}")
    
    raise Exception("Max retries exceeded")

✅ Giải pháp 2: Implement exponential backoff
def exponential_backoff_request(url, params):
    base_delay = 1
    max_delay = 60
    
    for attempt in range(5):
        response = requests.get(url, params=params)
        
        if response.status_code == 200:
            return response.json()
        elif response.status_code == 429:
            delay = min(base_delay * (2 ** attempt), max_delay)
            print(f"Attempt {attempt+1}: waiting {delay}s")
            time.sleep(delay)
        else:
            raise Exception(f"HTTP {response.status_code}")
    
    raise Exception("Failed after 5 attempts")

Lỗi 2: Response trống hoặc data rỗng

# ❌ Lỗi: API trả về [] hoặc không có data
Nguyên nhân: Symbol không tồn tại hoặc timeframe không hợp lệ

✅ Kiểm tra và validate trước request
VALID_INTERVALS = ['1m', '3m', '5m', '15m', '30m', '1h', '2h', 
                   '4h', '6h', '8h', '12h', '1d', '3d', '1w', '1M']

def get_klines_safe(symbol, interval, limit=500):
    # Validate interval
    if interval not in VALID_INTERVALS:
        raise ValueError(f"Invalid interval. Must be one of: {VALID_INTERVALS}")
    
    # Validate symbol format
    if not symbol.isupper():
        symbol = symbol.upper()
        print(f"Auto-corrected symbol to: {symbol}")
    
    url = "https://api.binance.com/api/v3/klines"
    params = {'symbol': symbol, 'interval': interval, 'limit': limit}
    
    response = requests.get(url, params=params)
    data = response.json()
    
    # Kiểm tra data rỗng
    if not data:
        print(f"⚠️ No data returned for {symbol} {interval}")
        return None
    
    print(f"✅ Retrieved {len(data)} klines for {symbol}")
    return data

✅ Kiểm tra số dư API limit
def get_rate_limit_status():
    """Kiểm tra trạng thái rate limit"""
    url = "https://api.binance.com/api/v3/account"
    # Cần signature - chỉ hoạt động với API key
    headers = {'X-MBX-APIKEY': 'YOUR_API_KEY'}
    response = requests.get(url, headers=headers)
    
    print(f"Headers: {response.headers}")
    print(f"X-MBX-USED-WEIGHT-1M: {response.headers.get('X-MBX-USED-WEIGHT-1M', 'N/A')}")

Lỗi 3: Timestamp Conversion sai

# ❌ Lỗi: Thời gian hiển thị sai hoặc timezone lệch
Nguyên nhân: Binance dùng millisecond timestamp

✅ Chuyển đổi đúng
import pandas as pd
from datetime import datetime, timezone

def convert_binance_timestamp(df, column='open_time'):
    """Convert timestamp chuẩn từ Binance"""
    # Binance trả về milliseconds
    df[column] = pd.to_datetime(df[column], unit='ms')
    
    # Chuyển sang UTC+7 ( giờ Việt Nam)
    df[column] = df[column].dt.tz_localize('UTC').dt.tz_convert('Asia/Ho_Chi_Minh')
    
    return df

✅ Hoặc với datetime thuần
def timestamp_to_datetime(timestamp_ms):
    """Convert milliseconds timestamp sang datetime"""
    # Tạo datetime object
    dt = datetime.fromtimestamp(timestamp_ms / 1000, tz=timezone.utc)
    
    # Chuyển sang giờ Việt Nam
    from datetime import timedelta
    vietnam_tz = timezone(timedelta(hours=7))
    dt_vietnam = dt.astimezone(vietnam_tz)
    
    return dt_vietnam

✅ Sử dụng trong code
df = pd.DataFrame({
    'open_time': [1640000000000, 1640000060000, 1640000120000]
})

df = convert_binance_timestamp(df)
print(df['open_time'])
Output: 2021-12-20 09:33:00+07:00

Lỗi 4: Memory Error khi lấy nhiều dữ liệu

# ❌ Lỗi: Out of memory khi fetch historical data lớn
Giải pháp: Xử lý theo batch

def fetch_historical_in_chunks(symbol, interval, start_time, end_time, 
                                chunk_size=1000):
    """Fetch data theo chunk để tránh memory error"""
    all_data = []
    current_start = start_time
    
    base_url = "https://api.binance.com/api/v3/klines"
    
    while current_start < end_time:
        params = {
            'symbol': symbol.upper(),
            'interval': interval,
            'startTime': current_start,
            'endTime': end_time,
            'limit': chunk_size
        }
        
        response = requests.get(base_url, params=params)
        data = response.json()
        
        if not data:
            break
        
        all_data.extend(data)
        current_start = data[-1][0] + 1  # Next batch
        
        # Process chunk ngay lập tức để giải phóng memory
        yield data
        
        # Delay để tránh rate limit
        time.sleep(0.3)
    
    print(f"✅ Total records fetched: {len(all_data)}")

✅ Sử dụng generator để xử lý
for i, chunk in enumerate(fetch_historical_in_chunks(
    symbol='BTCUSDT',
    interval='1h',
    start_time=1640000000000,
    end_time=1700000000000
)):
    print(f"Processing chunk {i+1} with {len(chunk)} records")
    # Process chunk ngay lập tức
    df_chunk = pd.DataFrame(chunk)
    # Save hoặc process...
    del df_chunk  # Giải phóng memory

Kết Luận Và Khuyến Nghị

Việc lấy dữ liệu K-line từ Binance API bằng Python là kỹ năng thiết yếu cho bất kỳ trader hoặc developer crypto nào. Với chi phí 0 đồng và độ trễ chấp nhận được (50-150ms), đây là lựa chọn tối ưu cho:

Backtest chiến lược giao dịch
Xây dựng trading bot cá nhân
Nghiên cứu thị trường
Học tập về phân tích kỹ thuật

Nếu bạn cần AI để phân tích dữ liệu K-line hoặc cần giải pháp API AI với chi phí thấp hơn 85% so với OpenAI, HolySheep AI là đối tác đáng cân nhắc với:

Tỷ giá ¥1=$1 — tiết kiệm đáng kể
Hỗ trợ WeChat/Alipay — thuận tiện cho người Việt
Độ trễ <50ms — nhanh hơn đa số đối thủ
Tín dụng miễn phí khi đăng ký

Tóm Tắt Nhanh

Thông số	Giá trị
Endpoint	https://api.binance.com/api/v3/klines
Rate limit	1200 requests/phút
Max records/request	1000
Độ trễ thực tế	50-150ms
Chi phí	Miễn phí (public data)
Yêu cầu API key	Không (chỉ public data)

👉 Đăng ký HolySheep AI — nhận tín dụng miễn phí khi đăng ký

Binance API Lấy Dữ Liệu K-line Lịch Sử Bằng Python — Hướng Dẫn Toàn Diện 2026

Mục Lục

Tổng Quan Về Binance K-line API

Ưu điểm của Binance API chính thức

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

Kiểm tra phiên bản Python (yêu cầu >= 3.8)

Tạo file .env để lưu API keys (nếu cần)

Code Python Hoàn Chỉnh

1. Lấy Dữ Liệu K-line Cơ Bản

Sử dụng

2. Code Nâng Cao với Async và Rate Limit Handling

Sử dụng async version

So Sánh Giải Pháp Lấy Dữ Liệu Crypto

Phù Hợp / Không Phù Hợp Với Ai

✅ Nên dùng Binance API khi:

❌ Không nên dùng khi:

Giá Và ROI

Vì Sao Chọn HolySheep AI

Lỗi Thường Gặp Và Cách Khắc Phục

Lỗi 1: HTTP 429 - Rate Limit Exceeded

Binance API trả về 429 khi vượt quá giới hạn request

✅ Giải pháp 1: Thêm delay giữa các request

✅ Giải pháp 2: Implement exponential backoff

Lỗi 2: Response trống hoặc data rỗng

Nguyên nhân: Symbol không tồn tại hoặc timeframe không hợp lệ

✅ Kiểm tra và validate trước request

✅ Kiểm tra số dư API limit

Lỗi 3: Timestamp Conversion sai

Nguyên nhân: Binance dùng millisecond timestamp

✅ Chuyển đổi đúng

✅ Hoặc với datetime thuần

✅ Sử dụng trong code

`Output: 2021-12-20 09:33:00+07:00`

Lỗi 4: Memory Error khi lấy nhiều dữ liệu

Giải pháp: Xử lý theo batch

✅ Sử dụng generator để xử lý

Kết Luận Và Khuyến Nghị

Tóm Tắt Nhanh

Tài nguyên liên quan

Bài viết liên quan

Mục Lục

Tổng Quan Về Binance K-line API

Ưu điểm của Binance API chính thức

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

Kiểm tra phiên bản Python (yêu cầu >= 3.8)

Tạo file .env để lưu API keys (nếu cần)

Code Python Hoàn Chỉnh

1. Lấy Dữ Liệu K-line Cơ Bản

Sử dụng

2. Code Nâng Cao với Async và Rate Limit Handling

Sử dụng async version

So Sánh Giải Pháp Lấy Dữ Liệu Crypto

Phù Hợp / Không Phù Hợp Với Ai

✅ Nên dùng Binance API khi:

❌ Không nên dùng khi:

Giá Và ROI

Vì Sao Chọn HolySheep AI

Lỗi Thường Gặp Và Cách Khắc Phục

Lỗi 1: HTTP 429 - Rate Limit Exceeded

Binance API trả về 429 khi vượt quá giới hạn request

✅ Giải pháp 1: Thêm delay giữa các request

✅ Giải pháp 2: Implement exponential backoff

Lỗi 2: Response trống hoặc data rỗng

Nguyên nhân: Symbol không tồn tại hoặc timeframe không hợp lệ

✅ Kiểm tra và validate trước request

✅ Kiểm tra số dư API limit

Lỗi 3: Timestamp Conversion sai

Nguyên nhân: Binance dùng millisecond timestamp

✅ Chuyển đổi đúng

✅ Hoặc với datetime thuần

✅ Sử dụng trong code

Output: 2021-12-20 09:33:00+07:00

Lỗi 4: Memory Error khi lấy nhiều dữ liệu

Giải pháp: Xử lý theo batch

✅ Sử dụng generator để xử lý

Kết Luận Và Khuyến Nghị

Tóm Tắt Nhanh

Tài nguyên liên quan

Bài viết liên quan

🔥 Thử HolySheep AI

`Output: 2021-12-20 09:33:00+07:00`