Overall Statistics Total Trades74Average Win0.57%Average Loss-0.37%Compounding Annual Return4.511%Drawdown5.700%Expectancy0.129Net Profit4.511%Sharpe Ratio0.657Loss Rate56%Win Rate44%Profit-Loss Ratio1.54Alpha0.008Beta0.291Annual Standard Deviation0.057Annual Variance0.003Information Ratio-0.763Tracking Error0.086Treynor Ratio0.129Total Fees\$116.16
```from System.Collections.Generic import List
from QuantConnect.Data.UniverseSelection import *

class CoarseFineFundamentalComboAlgorithm(QCAlgorithm):
'''In this algorithm we demonstrate how to define a universe as a combination of use the coarse fundamental data and fine fundamental data'''
def Initialize(self):
'''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''

self.SetStartDate(2014,01,01)  #Set Start Date
self.SetEndDate(2015,01,01)    #Set End Date
self.SetCash(50000)            #Set Strategy Cash

self.UniverseSettings.Resolution = Resolution.Daily

# this add universe method accepts two parameters:
# - coarse selection function: accepts an IEnumerable<CoarseFundamental> and returns an IEnumerable<Symbol>
# - fine selection function: accepts an IEnumerable<FineFundamental> and returns an IEnumerable<Symbol>
self.AddUniverse(self.CoarseSelectionFunction, self.FineSelectionFunction)

self.__numberOfSymbols = 5
self.__numberOfSymbolsFine = 2
self._changes = SecurityChanges.None

# sort the data by daily dollar volume and take the top 'NumberOfSymbols'
def CoarseSelectionFunction(self, coarse):
# sort descending by daily dollar volume
sortedByDollarVolume = sorted(coarse, key=lambda x: x.DollarVolume, reverse=True)

# return the symbol objects of the top entries from our sorted collection
top5 = sortedByDollarVolume[:self.__numberOfSymbols]

# we need to return only the symbol objects
list = List[Symbol]()
for x in top5:
list.Add(x.Symbol)

return list

# sort the data by P/E ratio and take the top 'NumberOfSymbolsFine'
def FineSelectionFunction(self, fine):
# sort descending by P/E ratio
sortedByPeRatio = sorted(fine, key=lambda x: x.ValuationRatios.PERatio, reverse=True)

# take the top entries from our sorted collection
topFine = sortedByPeRatio[:self.__numberOfSymbolsFine]

list = List[Symbol]()
for x in topFine:
list.Add(x.Symbol)

return list

def OnData(self, data):
# if we have no changes, do nothing
if self._changes == SecurityChanges.None: return

# liquidate removed securities
for security in self._changes.RemovedSecurities:
if security.Invested:
self.Liquidate(security.Symbol)

# we want 20% allocation in each security in our universe
for security in self._changes.AddedSecurities:
self.SetHoldings(security.Symbol, 0.2)

self._changes = SecurityChanges.None;

# this event fires whenever we have changes to our universe
def OnSecuritiesChanged(self, changes):
self._changes = changes```