self.aapl = self.add_equity("AAPL", Resolution.DAILY).symbol

_aapl = AddEquity("AAPL", Resolution.Daily).Symbol;

class USEquityDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2018, 1, 1)
        self.set_end_date(2021, 6, 1)
        self.set_cash(100000) 
        # Subscribe to AAPL data
        self.aapl = self.add_equity("AAPL", Resolution.MINUTE).symbol

namespace QuantConnect
{
    public class USEquityDataAlgorithm : QCAlgorithm
    {
        private Symbol _symbol; 
    	
        public override void Initialize()
        {
            SetStartDate(2018, 1, 1);
            SetEndDate(2021, 6, 1);
            SetCash(100000);
            // Subscribe to AAPL data
            _aapl = AddEquity("AAPL", Resolution.Minute).Symbol;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    # Access data: TradeBar data
    if self.aapl in slice.bars:
        trade_bar = slice.bars[self.aapl]
        self.log(f"{self.aapl} close at {slice.time}: {trade_bar.close}")

    # Access data: QuoteBar data
    if self.aapl in slice.quote_bars:
        quote_bar = slice.quote_bars[self.aapl]
        self.log(f"{self.aapl} bid at {slice.time}: {quote_bar.bid.close}")

    # Access data: Ticks data
    if self.aapl in slice.ticks:
        ticks = slice.ticks[self.aapl]
        for tick in ticks:
            self.log(f"{self.aapl} price at {slice.time}: {tick.price}")

public override void OnData(Slice slice)
{
    // Access data: TradeBar data
    if (slice.Bars.ContainsKey(_symbol))
    {
        var tradeBar = slice.Bars[_symbol];
        Log($"{_symbol} price at {slice.Time}: {tradeBar.Close}");
    }

    // Access data: QuoteBar data
    if (slice.QuoteBars.ContainsKey(_symbol))
    {
        var quoteBar = slice.QuoteBars[_symbol];
        Log($"{_symbol} bid at {slice.Time}: {quoteBar.Bid.Close}");
    }

    // Access data: Ticks data
    if (slice.Ticks.ContainsKey(_symbol))
    {
        var ticks = slice.Ticks[_symbol];
        foreach (var tick in ticks)
        {
            Log($"{_symbol} price at {slice.Time}: {tick.Price}");
        }
    }
}

def on_data(self, slice: Slice) -> None:
    # Iterate all TradeBar received
    for symbol, trade_bar in slice.bars.items():
        self.log(f"{symbol} close at {slice.time}: {trade_bar.close}")

    # Iterate all QuoteBar received
    for symbol, quote_bar in slice.quote_bars.items():
        self.log(f"{symbol} bid at {slice.time}: {quote_bar.bid.close}")

    # Iterate all Ticks received
    for symbol, ticks in slice.ticks.items():
        for tick in ticks:
            self.log(f"{symbol} price at {slice.time}: {tick.price}")

public override void OnData(Slice slice)
{
    // Iterate all TradeBar received
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        Log($"{symbol} price at {slice.Time}: {tradeBar.Close}");
    }

    // Iterate all QuoteBar received
    foreach (var kvp in slice.QuoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        Log($"{symbol} bid at {slice.Time}: {quoteBar.Bid.Close}");
    }

    // Iterate all Ticks received
    foreach (var kvp in slice.Ticks)
    {
        var symbol = kvp.Key;
        var ticks = kvp.Value;
        foreach (var tick in ticks)
        {
            Log($"{symbol} price at {slice.Time}: {tick.Price}");
        }
    }
}

# DataFrame
history_df = self.history(self.aapl, 100, Resolution.DAILY)

# TradeBar objects
history_trade_bars = self.history[TradeBar](self.aapl, 100, Resolution.DAILY)

# QuoteBar objects
history_quote_bars = self.history[QuoteBar](self.aapl, 100, Resolution.MINUTE)

# Tick objects
history_ticks = self.history[Tick](self.aapl, timedelta(seconds=10), Resolution.TICK)

// TradeBar objects 
var historyTradeBars = History(_symbol, 100, Resolution.Daily);

// QuoteBar objects 
var historyQuoteBars = History<QuoteBar>(_symbol, 100, Resolution.Minute);

// Tick objects 
var historyTicks = History<Tick>(_symbol, TimeSpan.FromSeconds(10), Resolution.Tick);

self.remove_security(self.aapl)

RemoveSecurity(_symbol);

from AlgorithmImports import *
from QuantConnect.DataSource import *

class USEquityDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2018, 1, 1)
        self.set_end_date(2021, 6, 1)
        self.set_cash(100000)
        
        # Requesting single equity data, since we only trade AAPL
        self.aapl = self.add_equity("AAPL", Resolution.DAILY).symbol
        
        # Historical data
        history = self.history(self.aapl, 60, Resolution.DAILY)
        self.debug(f"We got {len(history)} items from our history request")

    def on_data(self, slice: Slice) -> None:
        # Check if the current slice containing AAPL and if we hold any position
        # As we make use of the most updated price data to decide the order size
        if slice.contains_key(self.aapl) and slice[self.aapl] is not None and not self.portfolio.invested:
            self.set_holdings(self.aapl, 1)

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class USEquityDataAlgorithm : QCAlgorithm
    {
        private Symbol _symbol;
        
        public override void Initialize()
        {
            SetStartDate(2018, 1, 1);
            SetEndDate(2021, 6, 1);
            SetCash(100000);

            // Requesting single equity data, since we only trade AAPL
            _symbol = AddEquity("AAPL", Resolution.Daily).Symbol;
            
            // Historical data
            var history = History(_symbol, 60, Resolution.Daily);
            Debug($"We got {history.Count()} items from our history request");
        }

        public override void OnData(Slice slice)
        {
            // Check if the current slice containing AAPL and if we hold any position
            // As we make use of the most updated price data to decide the order size
            if (slice.ContainsKey(_symbol) && slice[_symbol] != null && !Portfolio.Invested)
            {
                SetHoldings(_symbol, 1);
            }
        }
    }
}

from AlgorithmImports import *
from QuantConnect.DataSource import *

class USEquityDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2018, 1, 1)
        self.set_end_date(2021, 6, 1)
        self.set_cash(100000)
        
        self.universe_settings.resolution = Resolution.DAILY
        # To select only AAPL, use a manual selection universe
        symbols = [Symbol.create("AAPL", SecurityType.EQUITY, Market.USA)]
        self.add_universe_selection(ManualUniverseSelectionModel(symbols))    
        
        # Constant investment signal
        self.add_alpha(ConstantAlphaModel(InsightType.PRICE, InsightDirection.UP, timedelta(days=7), 0.025, None))
        
        # Invest in all members equally
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class USEquityDataAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2018, 1, 1);
            SetEndDate(2021, 6, 1);
            SetCash(100000);
            
            UniverseSettings.Resolution = Resolution.Daily;
            // To select only AAPL, use a manual selection universe
            var symbols = new[] {QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA)};
            AddUniverseSelection(new ManualUniverseSelectionModel(symbols));
            
            // Constant investment signal
            AddAlpha(new ConstantAlphaModel(InsightType.Price, InsightDirection.Up, TimeSpan.FromDays(7), 0.025, null));

            // Invest in all members equally
            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
        }
    }
}