Door Portfoliodividendrendement berekenen
Bereken het portfoliodividendrendement als jaarlijks dividendinkomen gedeeld door marktwaarde. Lees waarom het gemiddelde van rendementen misleidt en marktwaardeweging nodig is.
Uw portfoliodividendrendement is één getal: het totale jaarlijkse dividendinkomen dat uw posities naar verwachting uitkeren, gedeeld door de totale marktwaarde van die posities. Anders geformuleerd is het een marktwaardegewogen gemiddelde van de individuele rendementen. Het gewicht van elke positie is daarbij de dollarwaarde als fractie van het geheel. Het gemiddelde van de rendementkolom op een brokerage-scherm is een ander getal. In de meeste echte portefeuilles is dat het flatterende getal.
Zo berekent u het portfoliodividendrendement
Vermenigvuldig voor elke positie het aantal aandelen met het jaarlijkse dividend per aandeel. Dat geeft het jaarlijkse inkomen van de positie in dollars. Tel die inkomens op, deel ze door de som van het aantal aandelen maal de koers voor alle posities en vermenigvuldig met 100. Dat is de volledige berekening, voor vier posities of veertig.
U kunt dit op twee gelijkwaardige manieren schrijven:
- Totaal jaarlijks inkomen gedeeld door de totale marktwaarde van de portefeuille.
- De som over alle posities van gewicht vermenigvuldigd met rendement, waarbij het gewicht de positiewaarde gedeeld door de portfoliowaarde is.
De tweede vorm laat zien waar een eenvoudig gemiddelde fout gaat. Elke positie komt in beide versies voor, maar in de juiste versie draagt elke positie het gewicht van zijn dollarwaarde en niet één stem. Cash dat u als onderdeel van de portefeuille meetelt, hoort ook in de noemer. Als u het weglaat, stijgt het weergegeven rendement zonder dat daar ook maar één cent inkomen tegenover staat. Voor de berekening van één aandeel begint u met hoe u het dividendrendement berekent.
Waarom het gemiddelde van de rendementkolom uw inkomen overschat
Het verschil tussen de twee methoden is het duidelijkst in een uitgewerkt voorbeeld. Het onderstaande script is gewone Python 3, zonder geïmporteerde modules. Het draait op elke machine met python3. De vijf posities zijn hypothetische ronde getallen, gekozen om het effect duidelijk te maken: een naam, een aantal aandelen, een koers en een jaarlijks dividend per aandeel.
#!/usr/bin/env python3
# each row: (name, shares, price, annual dividend per share)
holdings = [
('A', 200, 50.00, 1.50),
('B', 150, 100.00, 2.00),
('C', 100, 80.00, 0.80),
('D', 300, 20.00, 1.00),
('E', 100, 10.00, 0.90),
]
total_value = sum(sh * px for _, sh, px, _ in holdings)
total_income = sum(sh * dps for _, sh, _, dps in holdings)
naive = sum(100 * dps / px for _, _, px, dps in holdings) / len(holdings)
print(f'market value : ${total_value:,.2f}')
print(f'annual income : ${total_income:,.2f}')
print(f'portfolio yield : {100 * total_income / total_value:.2f}%')
print(f'average of yields : {naive:.2f}%')
for name, sh, px, dps in holdings:
value = sh * px
income = sh * dps
print(
f'{name} weight {100 * value / total_value:5.1f}%'
f' yield {100 * dps / px:5.2f}%'
f' income ${income:8,.2f}'
f' share of income {100 * income / total_income:5.1f}%'
)Voer het script uit en de twee hoofdregels wijken sterk van elkaar af. De portefeuille bevat voor $40.000 aan aandelen en keert jaarlijks $1.070 uit. Het gewogen rendement is 2,68%. Het eenvoudige gemiddelde van de vijf rendementcijfers komt uit op 4,00%, ongeveer anderhalf keer zo hoog.
Positie E verklaart het hele verschil. Deze positie heeft met 9,00% het hoogste rendement in de portefeuille, maar vertegenwoordigt slechts $1.000 aan aandelen. Dat is 2,5% van de portfoliowaarde en 8,4% van het inkomen. In het eenvoudige gemiddelde krijgt deze positie een vijfde van de stem, net als de positie van $15.000 ernaast. Een rendementcijfer heeft pas betekenis wanneer u het koppelt aan de dollarwaarde die erachter staat.
Hoe weging er bij echte posities uitziet
Dividendbetalende bedrijven in particuliere portefeuilles hebben rendementen die sterk uiteenlopen. Daardoor is de keuze van de weging belangrijk. Het onderstaande paneel berekent het trailing rendement van elke naam op basis van de gedeclareerde dividenden per aandeel over de afgelopen twaalf maanden, gedeeld door de meest recente slotkoers.
De exacte SQL achter elk getal
WITH
last_px AS
(
SELECT
ticker,
toFloat64(argMax(close, date)) AS px,
formatDateTime(max(date), '%b %e, %Y') AS priced_through
FROM global_markets.stocks_daily_aggs
WHERE ticker IN ('AAPL', 'MSFT', 'HD', 'KO', 'PG', 'PEP', 'JNJ', 'XOM', 'CVX', 'VZ')
AND date >= today() - 30
GROUP BY ticker
),
ttm_dps AS
(
SELECT
ticker,
sum(amount) AS dps
FROM
(
SELECT
ticker,
id,
toFloat64(any(cash_amount)) AS amount
FROM global_markets.stocks_dividends
WHERE ticker IN ('AAPL', 'MSFT', 'HD', 'KO', 'PG', 'PEP', 'JNJ', 'XOM', 'CVX', 'VZ')
AND ex_dividend_date > today() - 365
AND ex_dividend_date <= today()
GROUP BY ticker, id
)
GROUP BY ticker
)
SELECT
p.ticker AS symbol,
round(d.dps, 2) AS ttm_dividend_usd,
round(100 * d.dps / p.px, 2) AS yield_pct,
p.priced_through AS priced_through
FROM last_px AS p
INNER JOIN ttm_dps AS d ON d.ticker = p.ticker
ORDER BY yield_pct DESCBij deze 10 namen, geprijsd op basis van Aug 7, 2026, lopen de rendementen uiteen van 5.96% bij VZ tot 0.34% bij AAPL. Een portefeuille met een dergelijke spreiding komt alleen in de buurt van het midden van de kolom als de posities ongeveer even groot zijn in dollars.
Neem nu vijf van deze namen op in een portefeuille met een vast aantal aandelen. Vergelijk vervolgens twee cijfers: het aandeel van elke positie in de marktwaarde en het aandeel in het jaarlijkse inkomen.
De exacte SQL achter elk getal
WITH
positions AS
(
SELECT
tupleElement(p, 1) AS ticker,
toFloat64(tupleElement(p, 2)) AS shares
FROM
(
SELECT arrayJoin([('MSFT', 30.), ('PG', 60.), ('XOM', 80.), ('KO', 100.), ('VZ', 60.)]) AS p
)
),
last_px AS
(
SELECT
ticker,
toFloat64(argMax(close, date)) AS px
FROM global_markets.stocks_daily_aggs
WHERE ticker IN ('MSFT', 'PG', 'XOM', 'KO', 'VZ')
AND date >= today() - 30
GROUP BY ticker
),
ttm_dps AS
(
SELECT
ticker,
sum(amount) AS dps
FROM
(
SELECT
ticker,
id,
toFloat64(any(cash_amount)) AS amount
FROM global_markets.stocks_dividends
WHERE ticker IN ('MSFT', 'PG', 'XOM', 'KO', 'VZ')
AND ex_dividend_date > today() - 365
AND ex_dividend_date <= today()
GROUP BY ticker, id
)
GROUP BY ticker
),
holding AS
(
SELECT
pos.ticker AS ticker,
pos.shares * lp.px AS value_usd,
pos.shares * d.dps AS income_usd
FROM positions AS pos
INNER JOIN last_px AS lp ON lp.ticker = pos.ticker
INNER JOIN ttm_dps AS d ON d.ticker = pos.ticker
)
SELECT
h.ticker AS symbol,
round(100 * h.value_usd / t.total_value, 1) AS weight_pct,
round(100 * h.income_usd / t.total_income, 1) AS income_share_pct,
round(100 * h.income_usd / h.value_usd, 2) AS yield_pct
FROM holding AS h
CROSS JOIN
(
SELECT
sum(value_usd) AS total_value,
sum(income_usd) AS total_income
FROM holding
) AS t
ORDER BY weight_pct DESCHet patroon uit het script herhaalt zich bij live koersen. MSFT is met 31.4% van de marktwaarde de grootste positie en levert 10% van het inkomen, bij een rendement van 0.72%. Aan de andere kant vertegenwoordigt VZ 5.9% van de waarde en levert deze positie 15.7% van het inkomen, bij 5.96%. Het gewicht en het inkomensaandeel lopen uiteen zodra de rendementen verschillen.
Dezelfde vijf posities geven twee verschillende uitkomsten wanneer u ze op beide manieren middelt.
De exacte SQL achter elk getal
WITH
positions AS
(
SELECT
tupleElement(p, 1) AS ticker,
toFloat64(tupleElement(p, 2)) AS shares
FROM
(
SELECT arrayJoin([('MSFT', 30.), ('PG', 60.), ('XOM', 80.), ('KO', 100.), ('VZ', 60.)]) AS p
)
),
last_px AS
(
SELECT
ticker,
toFloat64(argMax(close, date)) AS px
FROM global_markets.stocks_daily_aggs
WHERE ticker IN ('MSFT', 'PG', 'XOM', 'KO', 'VZ')
AND date >= today() - 30
GROUP BY ticker
),
ttm_dps AS
(
SELECT
ticker,
sum(amount) AS dps
FROM
(
SELECT
ticker,
id,
toFloat64(any(cash_amount)) AS amount
FROM global_markets.stocks_dividends
WHERE ticker IN ('MSFT', 'PG', 'XOM', 'KO', 'VZ')
AND ex_dividend_date > today() - 365
AND ex_dividend_date <= today()
GROUP BY ticker, id
)
GROUP BY ticker
),
holding AS
(
SELECT
pos.shares * lp.px AS value_usd,
pos.shares * d.dps AS income_usd
FROM positions AS pos
INNER JOIN last_px AS lp ON lp.ticker = pos.ticker
INNER JOIN ttm_dps AS d ON d.ticker = pos.ticker
)
SELECT
tupleElement(m, 1) AS method,
round(tupleElement(m, 2), 2) AS yield_pct
FROM
(
SELECT arrayJoin([
('Market-value weighted portfolio yield', weighted_yield),
('Simple average of the five yields', naive_yield)
]) AS m
FROM
(
SELECT
100 * sum(income_usd) / sum(value_usd) AS weighted_yield,
avg(100 * income_usd / value_usd) AS naive_yield
FROM holding
)
)
ORDER BY yield_pct DESCDe hogere lijn, op 2.93%, is het cijfer voor Simple average of the five yields. De andere komt uit op 2.24%. Slechts één van beide correspondeert met cash. Vermenigvuldig het gewogen cijfer met de marktwaarde van de portefeuille en u krijgt het jaarlijkse inkomen terug. Als u hetzelfde doet met het eenvoudige gemiddelde, krijgt u een bedrag dat op geen enkel overzicht voorkomt. De richting van het verschil is structureel. Wanneer de namen met het hoogste rendement de kleinste posities zijn, ligt het eenvoudige gemiddelde boven het werkelijke portfoliorendement. Zijn de namen met het hoogste rendement de grootste posities, dan ligt het eenvoudige gemiddelde eronder.
Yield on cost is niet hetzelfde als portfoliorendement
Yield on cost deelt het huidige jaarlijkse dividend door de prijs die u hebt betaald, niet door de huidige waarde van de positie. Een positie die u voor $20 hebt gekocht en die nu op $80 noteert, terwijl zij nog steeds jaarlijks $1,00 per aandeel uitkeert, heeft een yield on cost van 5,00% tegenover een actueel rendement van 1,25%. Het dividendbedrag in dollars is hetzelfde. Alleen de noemer is veranderd.
Beide cijfers zijn legitiem en beantwoorden verschillende vragen. De huidige marktwaarde in de noemer laat zien welk rendement de portefeuille vandaag heeft. Dat is het cijfer dat u kunt vergelijken met een goed dividendrendement of met een Treasury bill. De cost basis in de noemer zegt iets over een aankoop in het verleden. Het probleem ontstaat wanneer u beide maatstaven in één portefeuilletotaal mengt: het actuele rendement voor recente aankopen en yield on cost voor posities die u al tien jaar aanhoudt. Die combinatie verdubbelt het ogenschijnlijke rendement van een inkomensportefeuille regelmatig en komt niet overeen met een cijfer dat een broker rapporteert. Dividendrendementvallen behandelt de tegenovergestelde illusie: een rendement dat hoog uitvalt na een sterke koersdaling.
Trailing- of forward-inputs veranderen de uitkomst
Elk hierboven genoemd cijfer hangt af van het dividendbedrag dat u in de teller gebruikt. Trailing yield telt de betalingen over de afgelopen twaalf maanden op die daadwerkelijk zijn gedeclareerd. Forward yield annualiseert de meest recente betaling, meestal het laatste kwartaalbedrag vermenigvuldigd met vier. De twee cijfers verschillen bij elke naam die de uitkering heeft gewijzigd of in de loop van het jaar een special distribution heeft betaald. Eén grote positie kan het portefeuilletotaal bovendien zelfstandig aanzienlijk veranderen. De panelen hier gebruiken trailing-inputs. Trailing versus forward dividendrendement laat zien wanneer elke maatstaf de juiste keuze is.
Het rendement is een percentage; de cash komt in bedragen
Een gewogen rendement is een jaarlijks percentage en geen betalingsschema. Dezelfde vijf posities keren hun dividend uit in een beperkt aantal geconcentreerde maanden. De meeste Amerikaanse bedrijven gaan elk kwartaal ex-dividend en volgen daarbij vergelijkbare kalenders.
De exacte SQL achter elk getal
WITH
positions AS
(
SELECT
tupleElement(p, 1) AS ticker,
toFloat64(tupleElement(p, 2)) AS shares
FROM
(
SELECT arrayJoin([('MSFT', 30.), ('PG', 60.), ('XOM', 80.), ('KO', 100.), ('VZ', 60.)]) AS p
)
),
payments AS
(
SELECT
ticker,
id,
any(ex_dividend_date) AS ex_date,
toFloat64(any(cash_amount)) AS amount
FROM global_markets.stocks_dividends
WHERE ticker IN ('MSFT', 'PG', 'XOM', 'KO', 'VZ')
AND ex_dividend_date > today() - 365
AND ex_dividend_date <= today()
GROUP BY ticker, id
)
SELECT
formatDateTime(toStartOfMonth(pay.ex_date), '%Y-%m') AS month,
formatDateTime(toStartOfMonth(pay.ex_date), '%b %Y') AS month_label,
round(sum(pos.shares * pay.amount), 2) AS income_usd
FROM payments AS pay
INNER JOIN positions AS pos ON pos.ticker = pay.ticker
GROUP BY month, month_label
ORDER BY monthDe cash kwam in 12 afzonderlijke maanden binnen gedurende het afgelopen jaar. De meest recente daarvan was Jul 2026, met $107.76. Een portfoliorendement van enkele procenten zegt niets over de maand waarin het geld binnenkomt. Daarom heeft een inkomensplan dat op een maandcijfer is gebaseerd naast het rendement ook de kalender nodig. Voor het marktniveau waarmee deze portfoliocijfers worden vergeleken, zie het dividendrendement van de S&P 500.
Veelgestelde vragen
Hoe bereken ik het dividendrendement van mijn volledige portefeuille?
Tel het jaarlijkse dividendinkomen van elke positie op: het aantal aandelen vermenigvuldigd met het jaarlijkse dividend per aandeel. Tel vervolgens de marktwaarde van elke positie op: het aantal aandelen vermenigvuldigd met de koers. Deel het totale inkomen door de totale waarde en vermenigvuldig met 100. Het resultaat is het marktwaardegewogen gemiddelde van de rendementen van uw posities.
Waarom is het gemiddelde van de rendementen van mijn posities hoger dan het portfoliorendement?
Een eenvoudig gemiddelde geeft elke positie één stem. Het portfoliorendement geeft elke positie een stem die evenredig is aan haar dollarwaarde. Wanneer de namen met het hoogste rendement uw kleinste posities zijn, ligt het eenvoudige gemiddelde boven het rendement dat de portefeuille daadwerkelijk oplevert. Het verschil kan oplopen tot ongeveer de helft extra.
Telt cash mee in het dividendrendement van een portefeuille?
Als u cash als onderdeel van de portefeuille beschouwt, hoort het met een dividend van nul in de noemer te staan. Het verlaagt dan het rendement. Als u cash uitsluit, rapporteert u alleen het rendement van het geïnvesteerde deel van de portefeuille. Beide conventies zijn bruikbaar, zolang u bij elke meting dezelfde conventie toepast.
Is yield on cost hetzelfde als het rendement van mijn portefeuille?
Nee. Yield on cost deelt het huidige dividend door de prijs die u jaren geleden hebt betaald. Daardoor stijgt het wanneer het aandeel in koers stijgt. Het portfoliorendement gebruikt de huidige marktwaarde. Dat is het cijfer dat aansluit op het inkomen dat uw huidige posities genereren.
Verhoogt één aandeel met een hoog rendement mijn portfoliorendement sterk?
Alleen in verhouding tot de dollarwaarde van die positie. Een aandeel met een rendement van 9% dat 2,5% van de portefeuille vertegenwoordigt, voegt ongeveer 0,2 procentpunt toe aan het gewogen rendement (0,09 vermenigvuldigd met 0,025). Het effect op het gemiddelde van de rendementkolom kan heel anders zijn.
Elk paneel bevat de exacte SQL waarmee het is geproduceerd. Daardoor is de weging regel voor regel controleerbaar. Als u dezelfde berekening wilt uitvoeren voor uw eigen lijst met namen en aantallen aandelen, kunt u dit in gewone Engelse taal aanvragen op de Strasmore-terminal.