Ask anyone doing serious market work what language they use and you’ll almost always get the same answer. Python for finance became the default for good reasons: the language reads nearly like English, it ships with batteries included, and the open-source data libraries built around it are some of the best software ever written, at any price. Hedge funds use them. Academic researchers use them. And – this is the part I love – a curious person with a laptop and a free API token can use the exact same tools. High-end tooling, made accessible to all.<\/p>\n
I’m a data nut, so rather than tell you Python is great, I’d rather show you. By the end of this guide you will have pulled real daily price history into Python, computed returns and volatility, and plotted the result – about 20 lines of code in total. No “what is Python” chapter and no machine learning detour. Just the actual work.<\/p>\n
There are hundreds of thousands of Python packages. Financial analysis with Python rests on a very small core of them:<\/p>\n
When you go deeper into statistics, Tutorials love toy CSVs. Markets are not toys, so let’s use real data: daily price history for Apple, pulled from our end-of-day API. If you want to follow along (please do – this is a typing-along kind of guide), grab a free API token at tiingo.com<\/a>. The free Starter plan is $0 and covers 500 unique symbols a month with 30+ years of price history, which is far more than everything in this article needs. We built the free tier to be genuinely useful on purpose – we don’t believe in holding good data hostage.<\/p>\n That’s the entire fetch. A list of dictionaries is fine. A DataFrame is better:<\/p>\n Three lines, each doing one job. Run Now the fun part. Let’s compute three of the most fundamental quantities in finance: daily returns, a moving average, and annualized volatility.<\/p>\n Line by line:<\/p>\n Three lines, and you’ve done genuine quantitative analysis – the same calculations that sit inside professional risk systems. One caveat that applies to everything in this guide: these numbers describe the past. They are not a prediction, and nothing here is investment advice.<\/p>\n Numbers in a table hide things a chart makes obvious. Context in markets is everything, and a chart is the fastest context there is.<\/p>\n Here is the gotcha that bites nearly everyone exactly once.<\/p>\n Suppose a company does a 4-for-1 stock split. Every shareholder now owns four shares at a quarter of the price, so economically nothing happened. But in the raw Dividends are subtler but just as real. When a company pays a dividend, its price typically dips by about that amount, but shareholders received cash. Raw closes record the dip and ignore the cash, so a returns series built on them understates what holding the stock actually earned. Compound that over years of a steady dividend payer and the gap becomes serious.<\/p>\n Adjusted prices fix both: splits and dividends are folded back into the series so the numbers reflect economic reality. That is why every calculation in this guide uses It is also exactly the kind of thing your data provider should carry for you. Corporate actions are constant, messy, and deeply unglamorous, and handling them well is a monk-like responsibility – clean data should be boring. Every price we serve is split- and dividend-adjusted and error-checked, precisely so that a returns calculation written at your kitchen table behaves like one written on a trading desk.<\/p>\n You now have the loop that most professional market work is built on: fetch, frame, compute, plot. Some natural next steps, in rough order of fun:<\/p>\n And yes, eventually machine learning, if that’s your thing – but the fundamentals above will carry you further than most people expect.<\/p>\n You don’t need expensive terminals or anyone’s permission to do real financial analysis anymore. A laptop, about 20 lines of Python, and good clean data will get you from zero to returns, volatility, and a chart in an afternoon. That accessibility is the whole reason Tiingo exists: we’ve been making high-end market data accessible and affordable since 2014, with no outside investors and 8+ years of profitability, which is what lets us keep asking “how much can we give?” instead of “how much can we charge?” Our motto is Actively Do Good, and handing a beginner the same data quality a fund gets is our favorite way of doing it.<\/p>\n The Starter plan is $0, and if you outgrow it, plans start at $30\/month<\/a> for individuals. Grab a free API token<\/a>, paste in the snippets above, and go analyze something. If you build something neat, we’d genuinely love to see it.<\/p>\n","protected":false},"excerpt":{"rendered":" Ask anyone doing serious market work what language they use and you’ll almost always get the same answer. Python for finance became the default for good reasons: the language reads nearly like English, it ships with batteries included, and the open-source data libraries built around it are some of the best software ever written, at […]<\/p>\n","protected":false},"author":1,"featured_media":688,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"osom_blocks_metabox":"","inline_featured_image":false,"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","footnotes":""},"categories":[6],"tags":[],"class_list":["post-291","post","type-post","status-publish","format-standard","has-post-thumbnail","category-engineering","entry"],"yoast_head":"\nscipy<\/code> and statsmodels<\/code> are waiting for you (hypothesis tests, regressions, and friends). But you can go a very long way with just the first three. Most exploratory market work is requests, pandas, and numpy, full stop.<\/p>\nGetting real market data into Python<\/h2>\n
import requests\n\nurl = \"https:\/\/api.tiingo.com\/tiingo\/daily\/aapl\/prices\"\nparams = {\"token\": \"YOUR_TOKEN\", \"startDate\": \"2024-01-01\"}\ndata = requests.get(url, params=params).json()<\/code><\/pre>\ndata<\/code> is now a list of dictionaries, one per trading day, and each one is a daily bar: date<\/code>, open<\/code>, high<\/code>, low<\/code>, close<\/code>, and volume<\/code>, plus adjusted versions of the prices and volume (adjClose<\/code>, adjOpen<\/code>, adjHigh<\/code>, adjLow<\/code>, adjVolume<\/code>). Hold that thought on the adjusted fields – they matter far more than most newcomers realize, and they get their own section below. The full response format is in our end-of-day API documentation<\/a>.<\/p>\nimport pandas as pd\n\ndf = pd.DataFrame(data)\ndf[\"date\"] = pd.to_datetime(df[\"date\"])\ndf = df.set_index(\"date\").sort_index()<\/code><\/pre>\npd.DataFrame(data)<\/code> turns the list into a table. pd.to_datetime<\/code> converts the date strings into real timestamps, which is what unlocks all of pandas’ time-series machinery. And set_index(\"date\").sort_index()<\/code> makes those dates the index, in chronological order, so slicing by date (df.loc[\"2024-03\"]<\/code> for one month, for example) just works.<\/p>\ndf.head()<\/code> and admire it for a second: a clean table of daily bars, one row per trading day, indexed by date. That structure – a datetime index with one column per field – is the foundation nearly all market data work in Python sits on. Get comfortable here and everything downstream gets easier.<\/p>\nYour first real analysis<\/h2>\n
import numpy as np\n\ndf[\"return\"] = np.log(df[\"adjClose\"]).diff()\ndf[\"ma20\"] = df[\"adjClose\"].rolling(20).mean()\nannualized_vol = df[\"return\"].std(ddof=1) * np.sqrt(252)<\/code><\/pre>\n\n
np.log(df[\"adjClose\"]).diff()<\/code> takes the logarithm of each adjusted close, then differences consecutive days. These are log returns, and quants are fond of them because they add cleanly across time: sum a month of daily log returns and you get the month’s log return. Notice we used adjClose<\/code> rather than close<\/code>. That is deliberate, and the section after next explains why.<\/li>\n.rolling(20).mean()<\/code> averages the prior 20 trading days at every point – roughly one month of trading. It smooths out the daily noise so the trend is visible.<\/li>\n.std(ddof=1)<\/code> is the sample standard deviation of those daily returns. Multiplying by np.sqrt(252)<\/code> scales it to an annual figure, because a year has about 252 trading days and volatility grows with the square root of time. That single number, annualized vol, is the standard yardstick for how bumpy a ride a stock has been.<\/li>\n<\/ul>\nPlotting it<\/h2>\n
import matplotlib.pyplot as plt\n\nfig, ax = plt.subplots(figsize=(10, 5))\nax.plot(df.index, df[\"adjClose\"], label=\"Adjusted close\")\nax.plot(df.index, df[\"ma20\"], label=\"20-day moving average\")\nax.set_title(\"AAPL adjusted close\")\nax.legend()\nplt.show()<\/code><\/pre>\nplt.subplots<\/code> creates the figure, the two ax.plot<\/code> calls draw the price and its rolling average against the date index, and plt.show()<\/code> renders it. You should see the price wiggling around a smoother line – the moving average trailing the close like a calm friend. When the two cross, that’s the kind of moment traders start arguing about.<\/p>\nWhy adjusted prices matter<\/h2>\n
close<\/code> column, the price just dropped roughly 75% overnight. If you compute returns from close<\/code> instead of adjClose<\/code>, your data now contains a catastrophic crash that never occurred, and every statistic downstream of it – volatility, correlations, backtest results – is quietly poisoned. One split can undo months of careful work.<\/p>\nadjClose<\/code>.<\/p>\nWhere to go next<\/h2>\n
\n
The bottom line<\/h2>\n