Beginner’s Guide to Trading Strategies with Python Code Examples

Receive Honest News Today

Join over 4 million Americans who start their day with 1440 – your daily digest for unbiased, fact-centric news. From politics to sports, we cover it all by analyzing over 100 sources. Our concise, 5-minute read lands in your inbox each morning at no cost. Experience news without the noise; let 1440 help you make up your own mind. Sign up now and invite your friends and family to be part of the informed.

Sign up today!

Exciting News: Paid Subscriptions Have Launched! 🚀

On September 1, we officially rolled out our new paid subscription plans at GuruFinance Insights, offering you the chance to take your investing journey to the next level! Whether you're just starting or are a seasoned trader, these plans are packed with exclusive trading strategies, in-depth research paper analysis, ad-free content, monthly AMAsessions, coding tutorials for automating trading strategies, and much more.

Our three tailored plans—Starter Investor, Pro Trader, and Elite Investor—provide a range of valuable tools and personalized support to suit different needs and goals. Don’t miss this opportunity to get real-time trade alerts, access to masterclasses, one-on-one strategy consultations, and be part of our private community group. Click here to explore the plans and see how becoming a premium member can elevate your investment strategy!

Check Out Latest Premium Articles

Trading strategies form the foundation of successful trading, offering a structured method to navigate the often-volatile financial markets. Whether you’re an experienced trader or a complete novice, grasping these strategies is essential for making smart choices and maximizing your earnings.

This guide highlights three widely-used trading strategies: position trading, swing trading, and day trading. We’ll delve into the basic concepts of each approach, discuss their advantages and drawbacks, and provide Python code samples to demonstrate their application.

Here’s what every Los Angeles Lakers fan should know

Love everything purple and gold? Now you can stay up to date and never miss any of the latest Lakers news with our free daily newsletter. Delivered right to your inbox, our podcast hosts send you expert analysis and insights, game previews and recaps, trade and draft buzz, the fantasy cheat sheet, and the news from around the NBA you need to know. Don’t miss the chance to stay connected to your favorite team in the NBA. Subscribe today for free so you can stay on top of all things Lakers.

Get the latest updates

1. Riding the Trend

Position trading emphasizes leveraging significant market trends over extended periods, often spanning days to weeks. This strategy focuses on identifying the dominant market direction and aligning trades accordingly, with positions being held for substantial durations.

Advantages:

• Less pressure due to infrequent trading actions.

• Opportunity to achieve considerable gains by capitalizing on long-term trends.

• Minimal influence from daily market swings, reducing emotional strain.

Disadvantages:

• Slower profit accumulation compared to short-term approaches.

• Limited adaptability to brief market fluctuations.

• Higher risk of retaining unprofitable positions over prolonged periods.

Python Code:

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

# Specify the stock symbol
stock_symbol = "AAPL"

# Fetch historical stock data
historical_data = yf.download(stock_symbol, period="1y", interval="1d")

# Compute moving averages for trend analysis
fast_ma = historical_data["Close"].rolling(window=50).mean()
slow_ma = historical_data["Close"].rolling(window=200).mean()

# Generate entry and exit signals
entry_points = (fast_ma > slow_ma) & (historical_data["Close"] > fast_ma)
exit_points = (fast_ma < slow_ma) | (historical_data["Close"] < fast_ma)

# Visualize price, moving averages, and trading signals
plt.figure(figsize=(12, 6))
plt.plot(historical_data["Close"], label="Stock Price", linewidth=1.5)
plt.plot(fast_ma, label="50-Day MA", linestyle="--", color="blue")
plt.plot(slow_ma, label="200-Day MA", linestyle="--", color="orange")
plt.scatter(historical_data.index[entry_points], historical_data["Close"][entry_points], 
            marker="^", color="green", label="Buy Signal", s=100)
plt.scatter(historical_data.index[exit_points], historical_data["Close"][exit_points], 
            marker="v", color="red", label="Sell Signal", s=100)
plt.title(f"{stock_symbol} Price and Moving Averages")
plt.xlabel("Date")
plt.ylabel("Price")
plt.legend()
plt.grid()
plt.show()

2. Harnessing Short-Term Price Moves

Swing trading centers on profiting from price fluctuations within a relatively brief timeframe, often ranging from several days to a few weeks. Practitioners of this strategy seek to pinpoint both rising and falling trends within the broader market context.

Advantages:

• Exploits price shifts over periods lasting from days to weeks.

• Takes advantage of both upward and downward market trends.

• Demands less time and effort compared to day trading.

Disadvantages:

• Vulnerability to overnight market volatility and price gaps.

• Potential to overlook quick intra-day price movements.

• Necessitates quick responses to unexpected market changes.

Python Code:

# Import necessary libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Specify the stock symbol
stock_symbol = "AAPL"

# Retrieve historical price data
price_data = yf.download(stock_symbol, period="1y", interval="1d")

# Compute the Relative Strength Index (RSI)
price_change = price_data["Close"].diff()
gains = price_change.clip(lower=0)
losses = -1 * price_change.clip(upper=0)
average_gain = gains.ewm(alpha=1/14).mean()
average_loss = losses.ewm(alpha=1/14).mean()
relative_strength = average_gain / average_loss
rsi_values = 100 - (100 / (1 + relative_strength))

# Generate trade signals based on RSI thresholds
entry_signals = (rsi_values < 30) & (price_data["Close"] > price_data["Close"].rolling(window=10).min())
exit_signals = (rsi_values > 70) & (price_data["Close"] < price_data["Close"].rolling(window=10).max())

# Create a visualization of price data and RSI-based signals
plt.figure(figsize=(12, 6))
plt.plot(price_data["Close"], label="Stock Price", linewidth=1.5)
plt.plot(rsi_values, label="RSI Indicator", linestyle="--", color="orange")
plt.scatter(price_data.index[entry_signals], price_data["Close"][entry_signals], 
            marker="^", color="green", label="Buy Signal", s=100)
plt.scatter(price_data.index[exit_signals], price_data["Close"][exit_signals], 
            marker="v", color="red", label="Sell Signal", s=100)
plt.title(f"RSI-Based Trading Signals for {stock_symbol}")
plt.xlabel("Date")
plt.ylabel("Price / RSI")
plt.legend()
plt.grid()
plt.show()

3. Exploiting Short-Term Volatility

Intraday trading focuses on entering and exiting trades within the same day, with the goal of profiting from brief price changes. Practitioners of this approach heavily rely on technical analysis to uncover lucrative opportunities in the market.

Advantages:

• Allows traders to achieve quick profits from short-term price shifts.

• Eliminates the uncertainties linked to holding positions overnight.

• Ensures that funds are available at the conclusion of each trading session.

Disadvantages:

• Demands intense mental and emotional discipline, requiring constant focus.

• High susceptibility to making rash choices under time pressure.

• Elevated trading costs resulting from frequent transactions.

Python Code:

# Import essential libraries
import pandas as pd
import numpy as np
import yfinance as yf
import matplotlib.pyplot as plt

# Set the stock ticker to analyze
stock_ticker = "AAPL"

# Fetch the historical data for the chosen stock
historical_prices = yf.download(stock_ticker, period="1y", interval="1d")

# Calculate the Bollinger Bands
price_std = historical_prices["Close"].rolling(window=20).std()
band_upper = historical_prices["Close"].rolling(window=20).mean() + (2 * price_std)
band_lower = historical_prices["Close"].rolling(window=20).mean() - (2 * price_std)

# Generate buy and sell signals
buy_signals = historical_prices["Close"] < band_lower
sell_signals = historical_prices["Close"] > band_upper

# Create a plot of the stock price and the Bollinger Bands
plt.figure(figsize=(12, 6))
plt.plot(historical_prices["Close"], label="Closing Price", color="blue")
plt.plot(band_upper, label="Upper Bollinger Band", linestyle="--", color="orange")
plt.plot(band_lower, label="Lower Bollinger Band", linestyle="--", color="orange")

# Mark buy and sell signals on the plot
plt.scatter(historical_prices.index[buy_signals], historical_prices["Close"][buy_signals], 
            marker="^", color="green", label="Buy Signal", s=100)
plt.scatter(historical_prices.index[sell_signals], historical_prices["Close"][sell_signals], 
            marker="v", color="red", label="Sell Signal", s=100)

# Add labels, title, and legend to the plot
plt.title(f"{stock_ticker} Price with Bollinger Bands")
plt.xlabel("Date")
plt.ylabel("Price")
plt.legend(loc="best")
plt.grid(True)
plt.show()