Create Candlestick Chart Plot using Python

In the realm of financial analysis, candlestick charts represent one of the most powerful visualization tools available. Their ability to display price movements, trends, and potential reversals makes them indispensable for traders, analysts, and financial enthusiasts. This comprehensive guide explores how to create effective candlestick charts using Python, from basic implementations to advanced customizations.

Table of Contents

Understanding Candlestick Charts Fundamentals

Candlestick charts originated in Japan during the 18th century when rice trader Munehisa Homma developed this technique to track price movements in rice contracts. Today, they’ve become the standard for visualizing financial market data worldwide.

A candlestick chart contains rich information at a glance. Each candlestick represents four crucial price points during a specific time period:

Open: Price at the beginning of the period
High: Highest price reached during the period
Low: Lowest price reached during the period
Close: Price at the end of the period

The body of the candlestick (the rectangle) shows the difference between opening and closing prices. When the closing price exceeds the opening price (bullish movement), the candle typically appears green or white. Conversely, when the closing price falls below the opening price (bearish movement), the candle appears red or black.

The thin lines extending from the body, called wicks or shadows, represent the high and low prices. The length of these wicks indicates volatility during the trading period.

Traders analyze various candlestick patterns to predict market behavior:

Doji: Indicates indecision when open and close prices are nearly identical
Hammer: Suggests potential reversal from a downtrend
Shooting Star: Indicates possible reversal from an uptrend
Engulfing Patterns: When one candle completely engulfs the previous one, suggesting a strong reversal

These patterns work across various timeframes, from minutes to months, making candlestick analysis remarkably versatile.

Python Libraries for Candlestick Visualization

Python offers several powerful libraries for creating candlestick charts. Each has unique strengths and best-use scenarios:

mplfinance: Built on Matplotlib, this specialized library creates elegant static candlestick charts with minimal code. It’s the successor to the deprecated finance module in Matplotlib.

Plotly: Offers interactive, web-based visualizations that allow users to zoom, hover over data points, and interact with the chart. Perfect for dashboards and web applications.

Matplotlib: The foundation visualization library in Python provides maximum flexibility for creating custom candlestick charts from scratch.

Alternative libraries: Bokeh, bqplot, and Altair offer additional approaches to financial visualization with different strengths in interactivity and styling.

To get started, install the necessary libraries:

pip install mplfinance plotly matplotlib pandas yfinance

When choosing a library, consider:

Static vs. interactive requirements
Customization needs
Integration with existing workflows
Performance with large datasets
Sharing and distribution plans

Data Preparation for Candlestick Charts

Creating effective candlestick charts begins with properly structured data. The OHLC (Open-High-Low-Close) format serves as the foundation for any candlestick visualization.

Python’s yfinance library provides a convenient way to acquire financial data:

import yfinance as yf
import pandas as pd

# Download data for a specific stock
ticker = "AAPL"
start_date = "2022-01-01"
end_date = "2022-06-30"
data = yf.download(ticker, start=start_date, end=end_date)

# Display the first few rows
print(data.head())

The resulting DataFrame contains the necessary OHLC data with dates as the index, making it ready for visualization. When working with external data sources, ensure proper formatting:

# Convert string dates to datetime objects
data['Date'] = pd.to_datetime(data['Date'])
data.set_index('Date', inplace=True)

# Handle missing values
data = data.dropna()  # Or use data.fillna(method='ffill')

# Ensure volume data is numeric
data['Volume'] = pd.to_numeric(data['Volume'], errors='coerce')

Properly prepared data forms the foundation for accurate and informative candlestick charts.

Creating Basic Candlestick Charts with mplfinance

The mplfinance library provides the most straightforward approach to creating professional-looking candlestick charts with minimal code. Built specifically for financial visualization, it offers a clean, intuitive API.

import mplfinance as mpf
import yfinance as yf

# Download Tesla stock data
symbol = "TSLA"
start_date = "2022-01-01"
end_date = "2022-03-30"
data = yf.download(symbol, start=start_date, end=end_date)

# Create a basic candlestick chart
mpf.plot(data, type='candle', title=f'{symbol} Stock Price',
         ylabel='Price ($)', volume=True, style='yahoo')

This code produces a complete candlestick chart with volume bars below the main chart. The style parameter offers predefined visual themes like ‘yahoo’, ‘charles’, ‘mike’, and ‘binance’.

For more customization, you can create a custom style:

# Create a custom style
custom_style = mpf.make_mpf_style(base_mpf_style='charles', 
                                 gridstyle=':', 
                                 y_on_right=False,
                                 marketcolors=mpf.make_marketcolors(up='green',
                                                                   down='red',
                                                                   inherit=True))

# Apply the custom style
mpf.plot(data, type='candle', style=custom_style, 
         title=f'{symbol} Stock Price',
         ylabel='Price ($)',
         volume=True,
         figsize=(12, 8))

To save the chart as an image file:

# Save the plot as a PNG file
mpf.plot(data, type='candle', style='yahoo', 
         title=f'{symbol} Stock Price',
         ylabel='Price ($)',
         volume=True,
         savefig='tesla_candlestick.png')

The mplfinance module handles non-trading days and gaps in data automatically, making it ideal for visualizing real market data.

Interactive Candlestick Charts with Plotly

While static charts work well for reports and publications, interactive visualizations provide a richer experience for data exploration. Plotly excels at creating interactive candlestick charts that can be embedded in web applications.

import plotly.graph_objects as go
import yfinance as yf

# Download data
symbol = "MSFT"
start_date = "2022-01-01"
end_date = "2022-06-30"
data = yf.download(symbol, start=start_date, end=end_date)

# Create an interactive candlestick chart
fig = go.Figure(data=[go.Candlestick(x=data.index,
                                    open=data['Open'],
                                    high=data['High'],
                                    low=data['Low'],
                                    close=data['Close'],
                                    name='OHLC')])

# Customize the layout
fig.update_layout(
    title=f'{symbol} Stock Price',
    yaxis_title='Price ($)',
    xaxis_rangeslider_visible=True,
    xaxis_title='Date',
    template='plotly_white'
)

# Show the figure
fig.show()

The interactive chart includes a range slider at the bottom for selecting specific time periods. Hovering over candlesticks reveals detailed information about prices.

Enhance the chart with additional features:

# Add range selector buttons
fig.update_layout(
    xaxis=dict(
        rangeselector=dict(
            buttons=list([
                dict(count=1, label="1m", step="month", stepmode="backward"),
                dict(count=6, label="6m", step="month", stepmode="backward"),
                dict(count=1, label="YTD", step="year", stepmode="todate"),
                dict(count=1, label="1y", step="year", stepmode="backward"),
                dict(step="all")
            ])
        ),
        rangeslider=dict(visible=True),
        type="date"
    )
)

# Add volume bars
fig.add_trace(go.Bar(x=data.index, y=data['Volume'], name='Volume',
                    marker=dict(color='rgba(128,128,128,0.5)')))

Save the interactive chart as an HTML file that can be opened in any web browser:

fig.write_html('interactive_candlestick.html')

Plotly’s interactive features make it ideal for building trading dashboards and sharing financial analyses with stakeholders.

Creating Candlestick Charts with Matplotlib

For maximum customization flexibility, you can create candlestick charts directly with Matplotlib:

import matplotlib.pyplot as plt
import pandas as pd
import yfinance as yf

# Download data
symbol = "AMZN"
start_date = "2022-01-01"
end_date = "2022-03-30"
data = yf.download(symbol, start=start_date, end=end_date)

# Create figure and axis
fig, ax = plt.subplots(figsize=(12, 6))

# Define width of candlestick elements
width = 0.4
width2 = 0.05

# Define up and down prices
up = data[data.Close >= data.Open]
down = data[data.Close < data.Open]

# Define colors
col1 = 'red'  # Down candles
col2 = 'green'  # Up candles

# Plot up prices
ax.bar(up.index, up.Close-up.Open, width, bottom=up.Open, color=col2)
ax.bar(up.index, up.High-up.Close, width2, bottom=up.Close, color=col2)
ax.bar(up.index, up.Low-up.Open, width2, bottom=up.Open, color=col2)

# Plot down prices
ax.bar(down.index, down.Close-down.Open, width, bottom=down.Open, color=col1)
ax.bar(down.index, down.High-down.Open, width2, bottom=down.Open, color=col1)
ax.bar(down.index, down.Low-down.Close, width2, bottom=down.Close, color=col1)

# Customize the chart
plt.title(f'{symbol} Stock Price', fontsize=15)
plt.xlabel('Date', fontsize=12)
plt.ylabel('Price ($)', fontsize=12)
plt.xticks(rotation=45)
plt.grid(alpha=0.3)

# Adjust layout and display
plt.tight_layout()
plt.show()

While this approach requires more code, it provides precise control over every visual element. You can customize colors, widths, labels, and other aspects to match your specific visualization requirements.

Adding Technical Indicators

Technical indicators enhance candlestick charts by providing additional insights into price movements and potential trading signals. Let’s implement some common indicators:

Simple Moving Average (SMA):

import mplfinance as mpf
import pandas as pd
import yfinance as yf

# Download data
data = yf.download("GOOGL", start="2022-01-01", end="2022-06-30")

# Calculate 20-day and 50-day SMAs
data['SMA20'] = data['Close'].rolling(window=20).mean()
data['SMA50'] = data['Close'].rolling(window=50).mean()

# Create additional plots for the indicators
apds = [
    mpf.make_addplot(data['SMA20'], color='blue', width=1),
    mpf.make_addplot(data['SMA50'], color='red', width=1)
]

# Plot candlestick chart with SMAs
mpf.plot(data, type='candle', style='yahoo', 
         title='GOOGL with Simple Moving Averages',
         ylabel='Price ($)',
         addplot=apds,
         volume=True,
         figsize=(12, 8))

Bollinger Bands:

# Calculate Bollinger Bands
def bollinger_bands(data, window=20, num_std=2):
    rolling_mean = data['Close'].rolling(window=window).mean()
    rolling_std = data['Close'].rolling(window=window).std()
    
    data['Bollinger_Upper'] = rolling_mean + (rolling_std * num_std)
    data['Bollinger_Middle'] = rolling_mean
    data['Bollinger_Lower'] = rolling_mean - (rolling_std * num_std)
    
    return data

data = bollinger_bands(data)

# Create plots for Bollinger Bands
apds = [
    mpf.make_addplot(data['Bollinger_Upper'], color='gray', width=1),
    mpf.make_addplot(data['Bollinger_Middle'], color='blue', width=1),
    mpf.make_addplot(data['Bollinger_Lower'], color='gray', width=1)
]

# Plot candlestick chart with Bollinger Bands
mpf.plot(data, type='candle', style='yahoo', 
         title='GOOGL with Bollinger Bands',
         ylabel='Price ($)',
         addplot=apds,
         volume=True,
         figsize=(12, 8))

RSI (Relative Strength Index):

# Calculate RSI
def calculate_rsi(data, window=14):
    delta = data['Close'].diff()
    gain = delta.where(delta > 0, 0).rolling(window=window).mean()
    loss = -delta.where(delta < 0, 0).rolling(window=window).mean()
    
    rs = gain / loss
    data['RSI'] = 100 - (100 / (1 + rs))
    return data

data = calculate_rsi(data)

# Create panel for RSI
apd = mpf.make_addplot(data['RSI'], panel=1, color='purple', ylabel='RSI')

# Plot candlestick chart with RSI
mpf.plot(data, type='candle', style='yahoo', 
         title='GOOGL with RSI',
         ylabel='Price ($)',
         addplot=apd,
         volume=True,
         figsize=(12, 10),
         panel_ratios=(2, 1))

Combining multiple indicators provides a more comprehensive view of market conditions and potential trading opportunities.

Advanced Customization Techniques

Take your candlestick charts to the next level with advanced customization options:

Custom Candlestick Colors Based on Conditions:

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

# Download data
data = yf.download("FB", start="2022-01-01", end="2022-06-30")

# Define custom market colors based on volume
my_marketcolors = mpf.make_marketcolors(
    up='green', down='red',
    edge={'up':'darkgreen', 'down':'darkred'},
    wick={'up':'green', 'down':'red'},
    volume={'up':'lightgreen', 'down':'lightcoral'},
)

# Create custom style
my_style = mpf.make_mpf_style(
    marketcolors=my_marketcolors,
    gridstyle=':',
    y_on_right=False
)

# Plot with custom style
mpf.plot(data, type='candle', style=my_style, 
         title='FB with Custom Colors',
         ylabel='Price ($)',
         volume=True,
         figsize=(12, 8))

Adding Annotations for Significant Events:

# Define events to annotate
events = [
    {'date': '2022-02-03', 'text': 'Earnings Report', 'color': 'blue'},
    {'date': '2022-04-27', 'text': 'Dividend', 'color': 'green'},
    {'date': '2022-05-15', 'text': 'Product Launch', 'color': 'purple'}
]

# Convert dates to the same format as the DataFrame index
for event in events:
    event['date'] = pd.to_datetime(event['date'])

# Create annotation list for mplfinance
annotations = []
for event in events:
    if event['date'] in data.index:
        annotations.append(
            mpf.make_addplot([], type='scatter', marker='^', 
                           markersize=100, color=event['color'],
                           secondary_y=False))

# Plot with annotations
mpf.plot(data, type='candle', style='yahoo',
         title='Stock with Event Annotations',
         ylabel='Price ($)',
         volume=True,
         figsize=(12, 8),
         addplot=annotations)

Multi-panel Financial Charts

Complex financial analysis often requires visualizing multiple indicators simultaneously. Multi-panel charts help organize this information effectively:

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

# Download data
data = yf.download("AAPL", start="2022-01-01", end="2022-06-30")

# Calculate indicators
# RSI
def calculate_rsi(data, window=14):
    delta = data['Close'].diff()
    gain = delta.where(delta > 0, 0).rolling(window=window).mean()
    loss = -delta.where(delta < 0, 0).rolling(window=window).mean()
    
    rs = gain / loss
    data['RSI'] = 100 - (100 / (1 + rs))
    return data

# MACD
def calculate_macd(data, fast_period=12, slow_period=26, signal_period=9):
    ema_fast = data['Close'].ewm(span=fast_period, adjust=False).mean()
    ema_slow = data['Close'].ewm(span=slow_period, adjust=False).mean()
    
    data['MACD'] = ema_fast - ema_slow
    data['MACD_Signal'] = data['MACD'].ewm(span=signal_period, adjust=False).mean()
    data['MACD_Histogram'] = data['MACD'] - data['MACD_Signal']
    return data

# Calculate indicators
data = calculate_rsi(data)
data = calculate_macd(data)

# Create additional plots
apds = [
    # RSI panel
    mpf.make_addplot(data['RSI'], panel=1, color='purple', ylabel='RSI'),
    # MACD panel
    mpf.make_addplot(data['MACD'], panel=2, color='blue', ylabel='MACD'),
    mpf.make_addplot(data['MACD_Signal'], panel=2, color='red'),
    mpf.make_addplot(data['MACD_Histogram'], panel=2, type='bar', color='gray')
]

# Plot multi-panel chart
mpf.plot(data, type='candle', style='yahoo',
         title='AAPL Multi-panel Analysis',
         ylabel='Price ($)',
         addplot=apds,
         volume=True,
         figsize=(12, 12),
         panel_ratios=(3, 1, 1, 1))  # Main chart, RSI, MACD, Volume

Multi-panel charts provide a comprehensive view of price action and technical indicators, helping traders identify potential entry and exit points.

Practical Applications in Trading and Analysis

Candlestick charts serve practical purposes in financial analysis:

Backtesting Trading Strategies:

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

# Download data
data = yf.download("SPY", start="2021-01-01", end="2022-06-30")

# Define a simple moving average crossover strategy
data['SMA50'] = data['Close'].rolling(window=50).mean()
data['SMA200'] = data['Close'].rolling(window=200).mean()

# Generate buy signals when short-term SMA crosses above long-term SMA
data['Signal'] = 0
data.loc[data['SMA50'] > data['SMA200'], 'Signal'] = 1

# Generate trading signals
data['Position'] = data['Signal'].diff()
data['Buy'] = np.where(data['Position'] == 1, data['Close'], np.nan)
data['Sell'] = np.where(data['Position'] == -1, data['Close'], np.nan)

# Plot candlestick chart with trading signals
apds = [
    mpf.make_addplot(data['SMA50'], color='blue', width=1),
    mpf.make_addplot(data['SMA200'], color='red', width=1),
    mpf.make_addplot(data['Buy'], type='scatter', markersize=100, marker='^', color='g'),
    mpf.make_addplot(data['Sell'], type='scatter', markersize=100, marker='v', color='r')
]

mpf.plot(data, type='candle', style='yahoo',
         title='SPY with SMA Crossover Strategy',
         ylabel='Price ($)',
         addplot=apds,
         volume=True,
         figsize=(12, 8))

Pattern Recognition:

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

# Download data
data = yf.download("NFLX", start="2021-01-01", end="2022-06-30")

# Identify Doji patterns (open and close prices are very close)
doji_threshold = 0.1  # % of the daily range
data['Range'] = data['High'] - data['Low']
data['Doji'] = np.where(abs(data['Close'] - data['Open']) < doji_threshold * data['Range'], data['Close'], np.nan)

# Plot candlestick chart with doji patterns highlighted
apds = [
    mpf.make_addplot(data['Doji'], type='scatter', markersize=100, marker='o', color='purple')
]

mpf.plot(data, type='candle', style='yahoo',
         title='NFLX with Doji Pattern Recognition',
         ylabel='Price ($)',
         addplot=apds,
         volume=True,
         figsize=(12, 8))

Best Practices and Performance Optimization

When creating candlestick charts in Python, consider these best practices:

1. Data Management for Large Datasets:

# Visualize the most recent 100 trading days
data_subset = data.iloc[-100:]
mpf.plot(data_subset, type='candle')

2. Ensuring Chart Readability:

Use consistent color schemes (green for up, red for down)
Include legends to explain indicators
Label axes and include informative titles
Format dates appropriately on the x-axis
Reduce x-axis label density for clearer visualization

3. Handling Missing Data:

# Forward-fill missing values
data = data.fillna(method='ffill')

# Or drop dates with missing values
data = data.dropna()

4. Performance Considerations:

Limit the number of indicators on a single chart
Use efficient calculations for technical indicators
Consider caching results for frequently used calculations
Use appropriate figure sizes for your display

Future Trends in Python Financial Visualization

The landscape of financial visualization in Python continues to evolve:

AI Integration: Machine learning models are increasingly being integrated with candlestick charts to identify patterns and predict market movements automatically.

Real-time Visualization: Libraries are enabling real-time updates to candlestick charts for live trading dashboards.

Cloud-based Solutions: Services like Streamlit and Dash make it easier to deploy interactive financial visualizations as web applications.

Community Developments: The open-source community regularly contributes new features and improvements to financial visualization libraries.

WebGL Rendering: Next-generation visualization tools are leveraging WebGL for faster rendering of large financial datasets.

VPS Manage Service Offer

If you don’t have time to do all of this stuff, or if this is not your area of expertise, we offer a service to do “VPS Manage Service Offer”, starting from $10 (Paypal payment). Please contact us to get the best deal!