6 posts tagged with "data-analysis"

import pandas as pd

# Tạo DataFrame
df = pd.DataFrame({
    'Tên': ['An', 'Bình', 'Cường'],
    'Tuổi': [25, 30, 35],
    'Lương': [1000, 2000, 3000]
})

# Hiển thị thống kê cơ bản
print(df.describe())

import numpy as np

# Tạo mảng
arr = np.array([1, 2, 3, 4, 5])

# Tính toán vector hóa
print(arr * 2)  # Nhân mỗi phần tử với 2
print(np.mean(arr))  # Tính trung bình

import matplotlib.pyplot as plt
import numpy as np

# Tạo dữ liệu
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Vẽ đồ thị
plt.plot(x, y)
plt.title('Đồ thị hàm sin')
plt.xlabel('x')
plt.ylabel('sin(x)')
plt.show()

import yfinance as yf

# Tải dữ liệu cổ phiếu
msft = yf.Ticker("MSFT")
hist = msft.history(period="1mo")

# Hiển thị dữ liệu
print(hist.head())

import talib
import numpy as np

# Tính RSI
close_prices = np.array([...])  # Dữ liệu giá đóng cửa
rsi = talib.RSI(close_prices)

# Tính MACD
macd, macd_signal, macd_hist = talib.MACD(close_prices)

import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.optimize import minimize

# Định nghĩa danh mục đầu tư
portfolio = {
    'AAPL': 0.3,  # Apple
    'MSFT': 0.3,  # Microsoft
    'GOOGL': 0.2, # Google
    'AMZN': 0.2   # Amazon
}

# Lấy dữ liệu lịch sử
data = pd.DataFrame()
for ticker in portfolio.keys():
    stock = yf.Ticker(ticker)
    hist = stock.history(period='1y')
    data[ticker] = hist['Close']

# Tính toán lợi nhuận hàng ngày
returns = data.pct_change()

# Hiển thị dữ liệu
print("Dữ liệu giá đóng cửa:")
print(data.head())
print("\nLợi nhuận hàng ngày:")
print(returns.head())

# Lợi nhuận trung bình hàng năm
annual_returns = returns.mean() * 252

# Độ lệch chuẩn (rủi ro)
volatility = returns.std() * np.sqrt(252)

# Tỷ lệ Sharpe (giả sử lãi suất phi rủi ro là 0.02)
risk_free_rate = 0.02
sharpe_ratio = (annual_returns - risk_free_rate) / volatility

# Tạo bảng tổng hợp
performance = pd.DataFrame({
    'Lợi nhuận hàng năm': annual_returns,
    'Độ biến động': volatility,
    'Tỷ lệ Sharpe': sharpe_ratio
})

# Hiển thị kết quả
print("\nPhân tích hiệu suất:")
print(performance)

# Vẽ biểu đồ so sánh
plt.figure(figsize=(12, 6))
performance['Lợi nhuận hàng năm'].plot(kind='bar')
plt.title('Lợi nhuận hàng năm của các tài sản')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Ma trận tương quan
correlation_matrix = returns.corr()

# Vẽ biểu đồ nhiệt
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', center=0)
plt.title('Ma trận tương quan giữa các tài sản')
plt.tight_layout()
plt.show()

# Vẽ biểu đồ phân tán
sns.pairplot(returns)
plt.suptitle('Phân tích phân tán giữa các tài sản', y=1.02)
plt.show()

def portfolio_volatility(weights, returns):
    return np.sqrt(np.dot(weights.T, np.dot(returns.cov() * 252, weights)))

def negative_sharpe(weights, returns, risk_free_rate):
    returns_array = returns.mean() * 252
    volatility = portfolio_volatility(weights, returns)
    return -(returns_array.dot(weights) - risk_free_rate) / volatility

# Tối ưu hóa danh mục
n_assets = len(portfolio)
constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
bounds = tuple((0, 1) for _ in range(n_assets))
initial_weights = np.array([1/n_assets] * n_assets)

optimal_weights = minimize(
    negative_sharpe,
    initial_weights,
    args=(returns, risk_free_rate),
    method='SLSQP',
    bounds=bounds,
    constraints=constraints
)

# Hiển thị kết quả tối ưu
print("\nPhân bổ tài sản tối ưu:")
for ticker, weight in zip(portfolio.keys(), optimal_weights.x):
    print(f"{ticker}: {weight:.2%}")

# Vẽ biểu đồ phân bổ
plt.figure(figsize=(10, 6))
plt.pie(optimal_weights.x, labels=portfolio.keys(), autopct='%1.1f%%')
plt.title('Phân bổ tài sản tối ưu')
plt.show()

# Value at Risk (VaR)
def calculate_var(returns, weights, confidence_level=0.95):
    portfolio_returns = returns.dot(weights)
    return np.percentile(portfolio_returns, (1 - confidence_level) * 100)

# Expected Shortfall (ES)
def calculate_es(returns, weights, confidence_level=0.95):
    portfolio_returns = returns.dot(weights)
    var = calculate_var(returns, weights, confidence_level)
    return portfolio_returns[portfolio_returns <= var].mean()

# Tính toán các chỉ số rủi ro
var_95 = calculate_var(returns, optimal_weights.x)
es_95 = calculate_es(returns, optimal_weights.x)

print(f"\nValue at Risk (95%): {var_95:.2%}")
print(f"Expected Shortfall (95%): {es_95:.2%}")

# Vẽ biểu đồ phân phối lợi nhuận
portfolio_returns = returns.dot(optimal_weights.x)
plt.figure(figsize=(10, 6))
sns.histplot(portfolio_returns, kde=True)
plt.axvline(var_95, color='r', linestyle='--', label=f'VaR (95%): {var_95:.2%}')
plt.axvline(es_95, color='g', linestyle='--', label=f'ES (95%): {es_95:.2%}')
plt.title('Phân phối lợi nhuận danh mục')
plt.xlabel('Lợi nhuận')
plt.ylabel('Tần suất')
plt.legend()
plt.show()

# Biểu đồ hiệu suất tích lũy
cumulative_returns = (1 + returns).cumprod()
plt.figure(figsize=(12, 6))
for column in cumulative_returns.columns:
    plt.plot(cumulative_returns.index, cumulative_returns[column], label=column)
plt.title('Hiệu suất tích lũy của danh mục')
plt.xlabel('Ngày')
plt.ylabel('Hiệu suất tích lũy')
plt.legend()
plt.grid(True)
plt.show()

# Biểu đồ phân bổ tài sản
plt.figure(figsize=(10, 6))
plt.pie(optimal_weights.x, labels=portfolio.keys(), autopct='%1.1f%%')
plt.title('Phân bổ tài sản tối ưu')
plt.show()

# Biểu đồ so sánh hiệu suất
plt.figure(figsize=(12, 6))
performance['Lợi nhuận hàng năm'].plot(kind='bar')
plt.title('So sánh lợi nhuận hàng năm')
plt.xlabel('Tài sản')
plt.ylabel('Lợi nhuận hàng năm')
plt.xticks(rotation=45)
plt.grid(True)
plt.show()

import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta

# Tạo đối tượng Ticker
aapl = yf.Ticker("AAPL")

# Lấy thông tin cơ bản
info = aapl.info
print("Thông tin cơ bản:")
print(f"Tên công ty: {info['longName']}")
print(f"Ngành: {info['industry']}")
print(f"Giá hiện tại: ${info['currentPrice']}")
print(f"Vốn hóa thị trường: ${info['marketCap']:,.2f}")

# Lấy dữ liệu 1 năm gần nhất
hist = aapl.history(period="1y")
print("\nDữ liệu lịch sử:")
print(hist.head())

# Vẽ biểu đồ giá đóng cửa
plt.figure(figsize=(12, 6))
plt.plot(hist.index, hist['Close'])
plt.title('Giá đóng cửa AAPL trong 1 năm')
plt.xlabel('Ngày')
plt.ylabel('Giá ($)')
plt.grid(True)
plt.show()

# Định nghĩa danh sách cổ phiếu
tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN']

# Lấy dữ liệu cho nhiều cổ phiếu
data = pd.DataFrame()
for ticker in tickers:
    stock = yf.Ticker(ticker)
    hist = stock.history(period='1y')
    data[ticker] = hist['Close']

# Tính toán lợi nhuận hàng ngày
returns = data.pct_change()

# Vẽ biểu đồ so sánh
plt.figure(figsize=(12, 6))
for column in data.columns:
    plt.plot(data.index, data[column], label=column)
plt.title('So sánh giá đóng cửa')
plt.xlabel('Ngày')
plt.ylabel('Giá ($)')
plt.legend()
plt.grid(True)
plt.show()

# Định nghĩa khoảng thời gian
start_date = '2020-01-01'
end_date = '2023-12-31'

# Lấy dữ liệu theo khoảng thời gian
hist = aapl.history(start=start_date, end=end_date)

# Tính toán các chỉ số
hist['Daily_Return'] = hist['Close'].pct_change()
hist['Cumulative_Return'] = (1 + hist['Daily_Return']).cumprod()

# Vẽ biểu đồ lợi nhuận tích lũy
plt.figure(figsize=(12, 6))
plt.plot(hist.index, hist['Cumulative_Return'])
plt.title('Lợi nhuận tích lũy AAPL')
plt.xlabel('Ngày')
plt.ylabel('Lợi nhuận tích lũy')
plt.grid(True)
plt.show()

# Tính toán các chỉ số thống kê
stats = pd.DataFrame({
    'Giá trung bình': hist['Close'].mean(),
    'Độ lệch chuẩn': hist['Close'].std(),
    'Giá cao nhất': hist['Close'].max(),
    'Giá thấp nhất': hist['Close'].min(),
    'Biến động trung bình': hist['Daily_Return'].std() * np.sqrt(252)
})

print("\nThống kê cơ bản:")
print(stats)

# Vẽ biểu đồ phân phối lợi nhuận
plt.figure(figsize=(12, 6))
sns.histplot(hist['Daily_Return'].dropna(), kde=True)
plt.title('Phân phối lợi nhuận hàng ngày')
plt.xlabel('Lợi nhuận')
plt.ylabel('Tần suất')
plt.show()

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

# Vẽ biểu đồ nhiệt
plt.figure(figsize=(10, 8))
sns.heatmap(correlation, annot=True, cmap='coolwarm', center=0)
plt.title('Ma trận tương quan giữa các cổ phiếu')
plt.show()

# Lấy báo cáo tài chính
financials = aapl.financials
balance_sheet = aapl.balance_sheet
cash_flow = aapl.cashflow

print("\nBáo cáo tài chính:")
print(financials.head())

# Vẽ biểu đồ doanh thu
plt.figure(figsize=(12, 6))
plt.bar(financials.columns, financials.loc['Total Revenue'])
plt.title('Doanh thu theo quý')
plt.xlabel('Quý')
plt.ylabel('Doanh thu ($)')
plt.xticks(rotation=45)
plt.show()

# Lấy thông tin cổ tức
dividends = aapl.dividends

# Vẽ biểu đồ cổ tức
plt.figure(figsize=(12, 6))
plt.bar(dividends.index, dividends)
plt.title('Lịch sử cổ tức')
plt.xlabel('Ngày')
plt.ylabel('Cổ tức ($)')
plt.grid(True)
plt.show()

# Lấy dữ liệu realtime
ticker = yf.Ticker("AAPL")
realtime = ticker.history(period="1d", interval="1m")

# Vẽ biểu đồ giá trong ngày
plt.figure(figsize=(12, 6))
plt.plot(realtime.index, realtime['Close'])
plt.title('Giá AAPL trong ngày')
plt.xlabel('Thời gian')
plt.ylabel('Giá ($)')
plt.grid(True)
plt.show()

import ccxt
import pandas as pd
import plotly.graph_objects as go
from datetime import datetime

# Khởi tạo exchange
exchange = ccxt.binance({
    'enableRateLimit': True,  # Tự động xử lý rate limit
    'options': {
        'defaultType': 'spot'  # Sử dụng spot trading
    }
})

# Kiểm tra kết nối
print(f"Exchange: {exchange.name}")
print(f"Markets: {len(exchange.markets)}")

def fetch_ohlcv(symbol, timeframe='1h', limit=1000):
    """
    Lấy dữ liệu OHLCV từ Binance
    
    Parameters:
    - symbol: Cặp giao dịch (ví dụ: 'BTC/USDT')
    - timeframe: Khung thời gian ('1m', '5m', '1h', '4h', '1d')
    - limit: Số lượng nến muốn lấy (tối đa 1000)
    """
    try:
        ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
        df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
        return df
    except Exception as e:
        print(f"Error fetching data: {e}")
        return None

# Ví dụ sử dụng
btc_data = fetch_ohlcv('BTC/USDT', '1h', 1000)
print(btc_data.head())

def fetch_multiple_ohlcv(symbol, timeframe='1h', since=None, limit=1000):
    """
    Lấy nhiều hơn 1000 nến bằng cách sử dụng since parameter
    """
    all_ohlcv = []
    while True:
        try:
            ohlcv = exchange.fetch_ohlcv(symbol, timeframe, since=since, limit=limit)
            if len(ohlcv) == 0:
                break
            all_ohlcv.extend(ohlcv)
            since = ohlcv[-1][0] + 1
        except Exception as e:
            print(f"Error: {e}")
            break
    return pd.DataFrame(all_ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])

def process_ohlcv_data(df):
    """
    Xử lý dữ liệu OHLCV
    """
    # Chuyển đổi timestamp
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    
    # Tính toán các chỉ báo
    df['returns'] = df['close'].pct_change()
    df['volatility'] = df['returns'].rolling(window=20).std()
    
    # Tính toán SMA
    df['SMA20'] = df['close'].rolling(window=20).mean()
    df['SMA50'] = df['close'].rolling(window=50).mean()
    
    return df

# Xử lý dữ liệu
btc_data = process_ohlcv_data(btc_data)

def save_data(df, filename, format='csv'):
    """
    Lưu dữ liệu ra file
    """
    if format == 'csv':
        df.to_csv(f"{filename}.csv", index=False)
    elif format == 'excel':
        df.to_excel(f"{filename}.xlsx", index=False)
    elif format == 'html':
        df.to_html(f"{filename}.html", index=False)
    else:
        print("Unsupported format")

# Ví dụ lưu dữ liệu
save_data(btc_data, 'btc_data', 'csv')
save_data(btc_data, 'btc_data', 'excel')

def plot_candlestick(df, title='BTC/USDT Price'):
    """
    Vẽ biểu đồ nến với Plotly
    """
    fig = go.Figure(data=[go.Candlestick(
        x=df['timestamp'],
        open=df['open'],
        high=df['high'],
        low=df['low'],
        close=df['close']
    )])
    
    # Thêm SMA
    fig.add_trace(go.Scatter(
        x=df['timestamp'],
        y=df['SMA20'],
        name='SMA20',
        line=dict(color='blue')
    ))
    
    fig.add_trace(go.Scatter(
        x=df['timestamp'],
        y=df['SMA50'],
        name='SMA50',
        line=dict(color='red')
    ))
    
    # Cập nhật layout
    fig.update_layout(
        title=title,
        yaxis_title='Price (USDT)',
        xaxis_title='Date',
        template='plotly_dark'
    )
    
    return fig

# Vẽ và hiển thị biểu đồ
fig = plot_candlestick(btc_data)
fig.show()

def plot_volume(df, title='BTC/USDT Volume'):
    """
    Vẽ biểu đồ volume
    """
    fig = go.Figure(data=[go.Bar(
        x=df['timestamp'],
        y=df['volume'],
        name='Volume'
    )])
    
    fig.update_layout(
        title=title,
        yaxis_title='Volume',
        xaxis_title='Date',
        template='plotly_dark'
    )
    
    return fig

# Vẽ và hiển thị biểu đồ volume
volume_fig = plot_volume(btc_data)
volume_fig.show()

def get_current_price(symbol):
    """
    Lấy giá hiện tại của một cặp giao dịch
    """
    try:
        ticker = exchange.fetch_ticker(symbol)
        return {
            'symbol': symbol,
            'last': ticker['last'],
            'bid': ticker['bid'],
            'ask': ticker['ask'],
            'volume': ticker['baseVolume'],
            'timestamp': datetime.fromtimestamp(ticker['timestamp']/1000)
        }
    except Exception as e:
        print(f"Error fetching ticker: {e}")
        return None

# Ví dụ lấy giá BTC/USDT
btc_ticker = get_current_price('BTC/USDT')
print(btc_ticker)

def fetch_multiple_symbols(symbols, timeframe='1h', limit=1000):
    """
    Lấy dữ liệu từ nhiều cặp giao dịch
    """
    data = {}
    for symbol in symbols:
        data[symbol] = fetch_ohlcv(symbol, timeframe, limit)
    return data

# Ví dụ lấy dữ liệu nhiều cặp
symbols = ['BTC/USDT', 'ETH/USDT', 'BNB/USDT']
multi_data = fetch_multiple_symbols(symbols)

def calculate_correlation(data_dict):
    """
    Tính toán tương quan giữa các cặp giao dịch
    """
    # Tạo DataFrame với giá đóng cửa của các cặp
    closes = pd.DataFrame()
    for symbol, df in data_dict.items():
        closes[symbol] = df['close']
    
    # Tính toán ma trận tương quan
    correlation = closes.corr()
    return correlation

# Tính và hiển thị tương quan
correlation = calculate_correlation(multi_data)
print(correlation)

import yfinance as yf
import pandas as pd
import numpy as np

# Tải dữ liệu chứng khoán
def get_stock_data(symbol, start_date, end_date):
    data = yf.download(symbol, start=start_date, end=end_date)
    return data

# Tải dữ liệu crypto
def get_crypto_data(symbol, start_date, end_date):
    data = yf.download(f"{symbol}-USD", start=start_date, end=end_date)
    return data

def process_market_data(data):
    # Tính toán các chỉ báo kỹ thuật
    data['Returns'] = data['Close'].pct_change()
    data['SMA_20'] = data['Close'].rolling(window=20).mean()
    data['SMA_50'] = data['Close'].rolling(window=50).mean()
    data['Volatility'] = data['Returns'].rolling(window=20).std()
    
    return data

def calculate_trend_indicators(data):
    # RSI
    delta = data['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
    data['RSI'] = 100 - (100 / (1 + rs))
    
    # MACD
    data['EMA_12'] = data['Close'].ewm(span=12).mean()
    data['EMA_26'] = data['Close'].ewm(span=26).mean()
    data['MACD'] = data['EMA_12'] - data['EMA_26']
    data['Signal_Line'] = data['MACD'].ewm(span=9).mean()
    
    return data

def calculate_volume_indicators(data):
    # OBV (On-Balance Volume)
    data['OBV'] = (np.sign(data['Close'].diff()) * data['Volume']).fillna(0).cumsum()
    
    # Volume SMA
    data['Volume_SMA_20'] = data['Volume'].rolling(window=20).mean()
    
    return data

def analyze_distribution(data):
    # Tính toán các thống kê cơ bản
    stats = {
        'mean': data['Returns'].mean(),
        'std': data['Returns'].std(),
        'skew': data['Returns'].skew(),
        'kurtosis': data['Returns'].kurtosis()
    }
    
    return stats

def analyze_correlation(data1, data2):
    # Tính toán hệ số tương quan
    correlation = data1['Returns'].corr(data2['Returns'])
    
    return correlation

def identify_candlestick_patterns(data):
    # Doji
    data['Doji'] = abs(data['Open'] - data['Close']) <= (data['High'] - data['Low']) * 0.1
    
    # Hammer
    data['Hammer'] = (data['Close'] > data['Open']) & \
                    ((data['High'] - data['Low']) > 3 * (data['Open'] - data['Low'])) & \
                    ((data['Close'] - data['Low']) / (0.001 + data['High'] - data['Low']) > 0.6)
    
    return data

def identify_price_patterns(data):
    # Double Top
    data['Double_Top'] = (data['High'].shift(1) < data['High']) & \
                        (data['High'] > data['High'].shift(-1)) & \
                        (abs(data['High'] - data['High'].shift(1)) < data['High'] * 0.01)
    
    return data

import matplotlib.pyplot as plt

def plot_price_data(data):
    plt.figure(figsize=(12, 6))
    plt.plot(data.index, data['Close'], label='Close Price')
    plt.plot(data.index, data['SMA_20'], label='20-day SMA')
    plt.plot(data.index, data['SMA_50'], label='50-day SMA')
    plt.title('Price Chart with Moving Averages')
    plt.legend()
    plt.show()

def plot_distribution(data):
    plt.figure(figsize=(10, 6))
    plt.hist(data['Returns'], bins=50, density=True)
    plt.title('Returns Distribution')
    plt.show()