SPX500Performance.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyO4+jYKnoNOB5KZtE3FGSv0",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Edu963/python_projects/blob/main/SPX500Performance.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "-4dALJgewjie"
      },
      "outputs": [],
      "source": [
        "#Download Libraries to Use\n",
        "import yfinance as yf\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Download historical S&P 500 data\n",
        "sp500_data = yf.download('^GSPC', start='2023-01-01', end='2023-12-31')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-wDybnWgw5lZ",
        "outputId": "9631c10b-efff-4b82-a40c-0fba1dbd926d"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\r[*********************100%%**********************]  1 of 1 completed\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(sp500_data)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_CBvCIlCCVW1",
        "outputId": "0fc6b166-aba5-4a43-caa6-ed3c8a7c55e7"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "    Symbol              Security             GICS Sector  \\\n",
            "0      MMM                    3M             Industrials   \n",
            "1      AOS           A. O. Smith             Industrials   \n",
            "2      ABT                Abbott             Health Care   \n",
            "3     ABBV                AbbVie             Health Care   \n",
            "4      ACN             Accenture  Information Technology   \n",
            "..     ...                   ...                     ...   \n",
            "498    YUM           Yum! Brands  Consumer Discretionary   \n",
            "499   ZBRA    Zebra Technologies  Information Technology   \n",
            "500    ZBH         Zimmer Biomet             Health Care   \n",
            "501   ZION  Zions Bancorporation              Financials   \n",
            "502    ZTS                Zoetis             Health Care   \n",
            "\n",
            "                      GICS Sub-Industry    Headquarters Location  Date added  \\\n",
            "0              Industrial Conglomerates    Saint Paul, Minnesota  1957-03-04   \n",
            "1                     Building Products     Milwaukee, Wisconsin  2017-07-26   \n",
            "2                 Health Care Equipment  North Chicago, Illinois  1957-03-04   \n",
            "3                         Biotechnology  North Chicago, Illinois  2012-12-31   \n",
            "4        IT Consulting & Other Services          Dublin, Ireland  2011-07-06   \n",
            "..                                  ...                      ...         ...   \n",
            "498                         Restaurants     Louisville, Kentucky  1997-10-06   \n",
            "499  Electronic Equipment & Instruments   Lincolnshire, Illinois  2019-12-23   \n",
            "500               Health Care Equipment          Warsaw, Indiana  2001-08-07   \n",
            "501                      Regional Banks     Salt Lake City, Utah  2001-06-22   \n",
            "502                     Pharmaceuticals   Parsippany, New Jersey  2013-06-21   \n",
            "\n",
            "         CIK      Founded  \n",
            "0      66740         1902  \n",
            "1      91142         1916  \n",
            "2       1800         1888  \n",
            "3    1551152  2013 (1888)  \n",
            "4    1467373         1989  \n",
            "..       ...          ...  \n",
            "498  1041061         1997  \n",
            "499   877212         1969  \n",
            "500  1136869         1927  \n",
            "501   109380         1873  \n",
            "502  1555280         1952  \n",
            "\n",
            "[503 rows x 8 columns]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the date range for 2023\n",
        "start_date = '2023-01-01'\n",
        "end_date = '2023-12-29'\n",
        "\n",
        "# Get the list of S&P 500 companies and their sectors\n",
        "sp500_data = pd.read_html('https://en.wikipedia.org/wiki/List_of_S%26P_500_companies')[0]\n",
        "sp500_tickers = sp500_data['Symbol'].tolist()\n",
        "sp500_sectors = sp500_data['GICS Sector'].tolist()\n",
        "\n",
        "# Create a DataFrame with tickers and sectors\n",
        "sp500_sectors_df = pd.DataFrame({'Ticker': sp500_tickers, 'Sector': sp500_sectors})\n",
        "\n",
        "# Group companies by sector\n",
        "grouped_companies = sp500_sectors_df.groupby('Sector')\n",
        "\n",
        "# Download financial data for each sector\n",
        "company_data_by_sector = pd.DataFrame()\n",
        "\n",
        "for sector, companies in grouped_companies:\n",
        "    for index, row in companies.iterrows():\n",
        "        ticker = row['Ticker']\n",
        "\n",
        "        try:\n",
        "            data = yf.download(ticker, start=start_date, end=end_date, progress=False)\n",
        "\n",
        "            # Add additional financial metrics if needed\n",
        "            data['Ticker'] = ticker\n",
        "            data['Sector'] = sector\n",
        "\n",
        "            company_data_by_sector = pd.concat([company_data_by_sector, data], axis=0)\n",
        "        except Exception as e:\n",
        "            print(f\"Error downloading data for {ticker}: {e}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G8NfgVxEw_vI",
        "outputId": "663cc558-d613-4cd3-da23-8630b019df83"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "ERROR:yfinance:\n",
            "1 Failed download:\n",
            "ERROR:yfinance:['BF.B']: Exception('%ticker%: No price data found, symbol may be delisted (1d 2023-01-01 -> 2023-12-29)')\n",
            "ERROR:yfinance:\n",
            "1 Failed download:\n",
            "ERROR:yfinance:['BRK.B']: Exception('%ticker%: No timezone found, symbol may be delisted')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the first few rows of the data\n",
        "print(company_data_by_sector.head())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DYeQVa7Myrjo",
        "outputId": "0aa72c95-70f3-4a61-958e-fb8258e59b4d"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "                 Open       High        Low      Close  Adj Close      Volume  \\\n",
            "Date                                                                            \n",
            "2023-01-03  89.589996  91.050003  88.519997  89.120003  89.120003  28131200.0   \n",
            "2023-01-04  90.349998  90.650002  87.269997  88.080002  88.080002  34854800.0   \n",
            "2023-01-05  87.470001  87.570000  85.900002  86.199997  86.199997  27194400.0   \n",
            "2023-01-06  86.790001  87.690002  84.860001  87.339996  87.339996  41381500.0   \n",
            "2023-01-09  88.360001  90.050003  87.860001  88.019997  88.019997  29003900.0   \n",
            "\n",
            "           Ticker                  Sector  \n",
            "Date                                       \n",
            "2023-01-03  GOOGL  Communication Services  \n",
            "2023-01-04  GOOGL  Communication Services  \n",
            "2023-01-05  GOOGL  Communication Services  \n",
            "2023-01-06  GOOGL  Communication Services  \n",
            "2023-01-09  GOOGL  Communication Services  \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a DataFrame to store the performance of each stock\n",
        "performance_data = pd.DataFrame()\n",
        "\n",
        "# Calculate the percentage change for each stock\n",
        "for ticker in sp500_tickers:\n",
        "    try:\n",
        "        data = yf.download(ticker, start=start_date, end=end_date, progress=False)\n",
        "\n",
        "        # Calculate the percentage change\n",
        "        data['Percentage Change'] = data['Close'].pct_change()\n",
        "\n",
        "        # Get the cumulative percentage change for the year\n",
        "        cumulative_percentage_change = (1 + data['Percentage Change']).cumprod() - 1\n",
        "\n",
        "        # Store the cumulative percentage change in the DataFrame\n",
        "        performance_data[ticker] = cumulative_percentage_change\n",
        "    except Exception as e:\n",
        "        print(f\"Error downloading data for {ticker}: {e}\")\n",
        "# Find the 5 best performers\n",
        "best_performers = performance_data.iloc[-1].sort_values(ascending=False).head(5)\n",
        "\n",
        "# Find the 5 worst performers\n",
        "worst_performers = performance_data.iloc[-1].sort_values().head(5)\n",
        "\n",
        "# Format the results as percentage\n",
        "best_performers = (best_performers * 100).round(2)\n",
        "worst_performers = (worst_performers * 100).round(2)\n",
        "\n",
        "# Display the results\n",
        "print(\"5 Best Performers:\")\n",
        "print(best_performers)\n",
        "\n",
        "print(\"\\n5 Worst Performers:\")\n",
        "print(worst_performers)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0anNWXixxQ6h",
        "outputId": "7605220f-54f8-450a-8eb5-8ff504f0845d"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "ERROR:yfinance:\n",
            "1 Failed download:\n",
            "ERROR:yfinance:['BRK.B']: Exception('%ticker%: No timezone found, symbol may be delisted')\n",
            "ERROR:yfinance:\n",
            "1 Failed download:\n",
            "ERROR:yfinance:['BF.B']: Exception('%ticker%: No price data found, symbol may be delisted (1d 2023-01-01 -> 2023-12-29)')\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5 Best Performers:\n",
            "NVDA    245.94\n",
            "META    187.25\n",
            "RCL     166.82\n",
            "BLDR    158.09\n",
            "UBER    148.97\n",
            "Name: 2023-12-28 00:00:00, dtype: float64\n",
            "\n",
            "5 Worst Performers:\n",
            "FMC    -49.32\n",
            "ENPH   -46.79\n",
            "DG     -45.06\n",
            "MRNA   -44.81\n",
            "PFE    -43.84\n",
            "Name: 2023-12-28 00:00:00, dtype: float64\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n",
            "<ipython-input-19-15b74981ac05>:16: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
            "  performance_data[ticker] = cumulative_percentage_change\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Download historical data for S&P 500 index\n",
        "sp500_history = yf.download('^GSPC', start=start_date, end=end_date, progress=False)\n",
        "\n",
        "# Calculate the percentage change for the S&P 500 index\n",
        "sp500_history['Percentage Change'] = sp500_history['Close'].pct_change()\n",
        "\n",
        "# Get the cumulative percentage change for the S&P 500 index\n",
        "sp500_cumulative_percentage_change = (1 + sp500_history['Percentage Change']).cumprod() - 1\n",
        "\n",
        "# Format the result as percentage\n",
        "sp500_cumulative_percentage_change = (sp500_cumulative_percentage_change * 100).round(2)\n",
        "\n",
        "# Display the result\n",
        "print(\"Cumulative Percentage Change for S&P 500 in 2023:\")\n",
        "print(sp500_cumulative_percentage_change)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-_F8uiI2BKNo",
        "outputId": "59fee85f-d0c1-4c57-becb-492b6cf2cf74"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cumulative Percentage Change for S&P 500 in 2023:\n",
            "Date\n",
            "2023-01-03      NaN\n",
            "2023-01-04     0.75\n",
            "2023-01-05    -0.42\n",
            "2023-01-06     1.86\n",
            "2023-01-09     1.78\n",
            "              ...  \n",
            "2023-12-21    24.13\n",
            "2023-12-22    24.33\n",
            "2023-12-26    24.86\n",
            "2023-12-27    25.04\n",
            "2023-12-28    25.08\n",
            "Name: Percentage Change, Length: 249, dtype: float64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# Define the date range for the year 2023\n",
        "start_date = '2023-01-01'\n",
        "end_date = '2023-12-29'\n",
        "\n",
        "\n",
        "\n",
        "# Plot the cumulative percentage change for the S&P 500\n",
        "plt.figure(figsize=(12, 6))\n",
        "plt.plot(sp500_cumulative_percentage_change.index, sp500_cumulative_percentage_change, label='S&P 500 (GSPC)', color='#4d7298', linewidth=2)\n",
        "plt.xlabel('Date')\n",
        "plt.ylabel('Cumulative Percentage Change')\n",
        "plt.title('Cumulative Percentage Change for S&P 500 in 2023')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 371
        },
        "id": "3AE-7esZFXXH",
        "outputId": "2c09868b-9f70-4176-9246-ae4dcc91a06f"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the date range for 2022 and 2023\n",
        "start_date_2022 = '2022-01-01'\n",
        "end_date_2022 = '2022-12-31'\n",
        "\n",
        "start_date_2023 = '2023-01-01'\n",
        "end_date_2023 = '2023-12-31'\n",
        "\n",
        "# Download historical data for S&P 500 index for 2022 and 2023\n",
        "sp500_history_2022 = yf.download('^GSPC', start=start_date_2022, end=end_date_2022, progress=False)\n",
        "sp500_history_2023 = sp500_history\n",
        "\n",
        "# Calculate the percentage change for each day for 2022 and 2023\n",
        "sp500_percentage_change_2022 = sp500_history_2022['Close'].pct_change()\n",
        "sp500_percentage_change_2023 = sp500_history_2023['Close'].pct_change()\n",
        "\n",
        "# Calculate the cumulative percentage change for 2022 and 2023\n",
        "sp500_cumulative_percentage_change_2022 = (1 + sp500_percentage_change_2022).cumprod() - 1\n",
        "sp500_cumulative_percentage_change_2023 = (1 + sp500_percentage_change_2023).cumprod() - 1\n",
        "\n",
        "# Format the results as percentage\n",
        "sp500_cumulative_percentage_change_2022 = (sp500_cumulative_percentage_change_2022 * 100).round(2)\n",
        "sp500_cumulative_percentage_change_2023 = (sp500_cumulative_percentage_change_2023 * 100).round(2)\n",
        "\n",
        "# Plot the cumulative percentage change for 2022 and 2023\n",
        "plt.figure(figsize=(12, 6))\n",
        "plt.plot(sp500_cumulative_percentage_change_2022, label='S&P 500 (GSPC) - 2022', color = '#e89005', linewidth = 2)\n",
        "plt.plot(sp500_cumulative_percentage_change_2023, label='S&P 500 (GSPC) - 2023', color = '#b3d89c', linewidth = 2)\n",
        "plt.xlabel('Date')\n",
        "plt.ylabel('Cumulative Percentage Change')\n",
        "plt.title('Comparison of S&P 500 Performance: 2022 vs 2023')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 367
        },
        "id": "7qTWQN2EJpEH",
        "outputId": "6f134be6-e7ba-4521-fec1-e74714cbd3c5"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the date range for the past 20 years\n",
        "start_date = '2003-01-01'\n",
        "end_date = '2023-12-29'\n",
        "\n",
        "# Download historical data for S&P 500 index\n",
        "sp500_history = yf.download('^GSPC', start=start_date, end=end_date, progress=False)\n",
        "\n",
        "# Calculate the daily percentage change\n",
        "sp500_daily_percentage_change = sp500_history['Close'].pct_change()\n",
        "# Calculate the daily percentage change\n",
        "sp500_daily_percentage_change = sp500_history['Close'].pct_change()\n",
        "# Calculate the annualized percentage change\n",
        "sp500_annual_percentage_change = sp500_daily_percentage_change.groupby(sp500_daily_percentage_change.index.year).apply(lambda x: (1 + x).prod() - 1) * 100\n",
        "\n",
        "# Plot the annual returns with color based on value\n",
        "plt.figure(figsize=(12, 6))\n",
        "colors = ['#e89005' if val < 0 else '#b3d89c' for val in sp500_annual_percentage_change]\n",
        "sp500_annual_percentage_change.plot(kind='bar', color=colors)\n",
        "plt.xlabel('Year')\n",
        "plt.ylabel('Annual Percentage Change')\n",
        "plt.title('S&P 500 Annual Returns (2003-2022)')\n",
        "plt.axhline(0, color='black', linestyle='--', linewidth=1)  # Add a horizontal line at 0 for reference\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 381
        },
        "id": "jEqKmJLLOGpg",
        "outputId": "94311481-8ee7-4419-b485-df7141c18b9f"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate the average annual return\n",
        "average_annual_return = sp500_annual_percentage_change.mean()\n",
        "\n",
        "print(f\"Average Annual Return of S&P 500 (GSPC) over the past 20 years: {average_annual_return:.2f}%\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "raZiNaKoP7dN",
        "outputId": "1b7b0803-ba89-43ed-c5c6-0016dd8b8f75"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Average Annual Return of S&P 500 (GSPC) over the past 20 years: 9.66%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "UWxfjFFMRNp-"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}