Automated Trading Development in Python, Getting Started with Zipline

In recent years, automated trading has received significant attention in the financial markets. This is because it helps investors make more efficient trading decisions without being swayed by emotions by automatically executing trades through algorithms. Python is a highly suitable language for developing such automated trading systems, with various libraries and tools available. Among these, Zipline is one of the most well-known Python-based automated trading frameworks. In this article, I will introduce how to build an automated trading system using Zipline.

1. Introduction to Zipline

Zipline is a Python-based backtesting framework developed by Alfred S. Van der Veen, designed for research and testing investment strategies. Zipline leverages Python’s powerful capabilities to provide an environment where users can easily and quickly implement trading strategies.

1.1 Features of Zipline

• User-friendly API: Zipline offers an intuitive API that is easy to use.
• Strong backtesting capabilities: With Zipline, you can apply strategies to the past to evaluate their performance.
• Integration with numerous data sources: It is easy to access real-time and historical data from various data sources such as Quandl and Yahoo Finance.
• Support for multi-asset trading strategies: Zipline can simultaneously test and execute trading strategies across multiple assets.
• Open-source: Zipline is an open-source project that can be freely used and is continuously improved by the community.

2. Setting Up the Development Environment

To use Zipline, you must first set up your development environment. Let’s go through the following steps.

2.1 Installing Anaconda

It is most efficient to use Zipline with Anaconda. Anaconda is a platform that allows for easy management and installation of various Python libraries. To install Anaconda, visit the link below, download the installation file suitable for your operating system, and install it.

Download Anaconda

2.2 Installing Zipline

Once Anaconda is installed, you can install Zipline using the command below. Open Anaconda Prompt and type the following command.

conda install -c conda-forge zipline

This command installs Zipline from the conda-forge repository. Once the installation is complete, you will be ready to use Zipline.

3. Basic Usage of Zipline

After installing Zipline, let’s implement a simple trading strategy to learn the basic usage.

3.1 Defining Trading Strategy

In this example, we will use a simple moving average crossover strategy. This strategy buys when the short-term moving average crosses above the long-term moving average and sells when it crosses below.

3.2 Writing the Strategy Code

Here is the code to implement a moving average crossover strategy using Zipline:

import zipline
    from zipline.api import order, record, symbol
    from zipline import run_algorithm
    import pandas as pd
    from datetime import datetime
    import pytz

    def initialize(context):
        context.asset = symbol('AAPL')  # Using Apple stock
        context.short_mavg = 50  # Short term moving average period
        context.long_mavg = 200   # Long term moving average period

    def handle_data(context, data):
        short_mavg = data.history(context.asset, 'price', context.short_mavg, '1d').mean()
        long_mavg = data.history(context.asset, 'price', context.long_mavg, '1d').mean()

        if short_mavg > long_mavg and context.asset not in context.portfolio.positions:
            order(context.asset, 10)  # Buy
        elif short_mavg < long_mavg and context.asset in context.portfolio.positions:
            order(context.asset, -10)  # Sell

        record(AAPL=data.current(context.asset, 'price'))

    start = datetime(2015, 1, 1, 0, 0, 0, tzinfo=pytz.UTC)
    end = datetime(2020, 1, 1, 0, 0, 0, tzinfo=pytz.UTC)

    run_algorithm(start=start,
                  end=end,
                  initialize=initialize,
                  capital_base=10000,
                  handle_data=handle_data,
                  bundle='quantopian-quandl')
    

3.3 Explaining the Code

The above code is an example of a simple algorithmic trading system that operates within Zipline. Each function has the following roles:

• initialize(context): Called once at the beginning of the algorithm to initialize necessary variables. Here, it sets the asset to trade (AAPL) and defines moving average periods.
• handle_data(context, data): Called at each trade, this function calculates the current asset's short-term and long-term moving averages and executes trades based on conditions.
• record(): Saves the values of variables on each trading day to allow for later analysis.
• run_algorithm(): Responsible for executing the entire algorithm, accepting start and end dates, initial capital, and various settings as parameters.

4. Using Data After Installing Zipline

When using Zipline, you need to import data. Zipline operates in conjunction with data bundles, so it is common to use Quantopian's Quandl data. To do this, you need to download and configure the data bundle first.

4.1 Setting Up the Data Bundle

Use the following command to download the Quandl data bundle. Type the following in Anaconda Prompt:

zipline ingest -b quantopian-quandl

This command downloads stock prices and other economic data from Quandl and sets them up for use in Zipline.

4.2 Checking the Data

After the download is complete, you can check and use the data. Use the following code to print out the data for the AAPL stock:

from zipline.data import bundles
    import pandas as pd

    # Load the data bundle
    bundle_data = bundles.load('quantopian-quandl')
    asset_data = bundle_data.asset_finder.retrieve_all([
        symbol('AAPL')
    ])

    # Convert data to DataFrame and print
    aapl_data = pd.DataFrame(asset_data)
    print(aapl_data)
    

5. Optimizing Strategies with Zipline

Strategy optimization is a very important process in automated trading. You can improve performance by adjusting various parameters. Here’s how to optimize strategies by changing parameters using Zipline.

5.1 Adjusting Parameters

In the basic algorithm above, perform several backtests by changing the short-term and long-term moving average periods. Here’s the code that adjusts the short-term and long-term moving average periods while returning results:

def run_multiple_backtests(short_mavg_list, long_mavg_list):
        results = {}
        for short_mavg in short_mavg_list:
            for long_mavg in long_mavg_list:
                result = run_algorithm(start=start,
                                       end=end,
                                       initialize=lambda context: initialize(context, short_mavg, long_mavg),
                                       capital_base=10000,
                                       handle_data=handle_data,
                                       bundle='quantopian-quandl')
                results[(short_mavg, long_mavg)] = result
        return results

    results = run_multiple_backtests(short_mavg_list=[10, 20, 50],
                                      long_mavg_list=[100, 150, 200])
    

You can visualize the results to see which combination is the most effective. This process helps make the right decisions based on data.

6. Visualizing and Evaluating Results

After backtesting the strategy, it is important to visualize the results for performance evaluation. Zipline allows the use of a library called Pyfolio. Pyfolio is a tool that analyzes the performance of investment strategies and provides results visually.

6.1 Installing Pyfolio

To install Pyfolio, enter the command below.

pip install pyfolio

6.2 Visualizing Results

You can now visualize results using Pyfolio. Refer to the following code:

import pyfolio as pf

    # Pass Zipline results to Pyfolio
    pf.create_full_tear_sheet(results[(50, 200)])
    

Conclusion

In this article, I introduced Zipline as the first step in developing an automated trading system using Python and explored how to implement a basic trading strategy. With powerful tools like Zipline, financial data analysis, strategy development, and optimization are possible, and we also learned how to visualize and evaluate performance. I hope you can execute more efficient and successful investment strategies through automated trading. May your future investment journey be filled with good fortune!