Dauer der Rückzahlung durch Dividenden

[Bolitho]

Hallo und guten Morgen,

ich brauche mal die Mathematiker unter euch:

Code: Alles auswählen

kaufpreis = 100
dividende = 5
dividendenwachstum = 10  # in %
dividendeneinnahmen = 0
jahre = 0

while dividendeneinnahmen < kaufpreis:
    dividendeneinnahmen += dividende
    jahre += 1
    dividende += dividende * dividendenwachstum / 100  # Dividende wird für das nächste Jahr erhöht

print(jahre)

Der Code berechnet die Dauer der Rückzahlung des Kaufpreises einer Aktie durch Dividenden. Funktioniert, alles gut. Aber das muss doch auch smarter gehen. Inspiriert mich!

(Disclaimer: Code aus diesem Thread könnte produktiv auf divipedia.de genutzt werden. Die Seite stellt kostenfrei Informationen zu Aktien und zur Dividendenstrategie zur Verfügung. Werbung auf der Seite dient der Kostensenkung durch das Projekt.)

[kbr]

Wenn du die Aufgabe algebraisch lösen möchtest und eine Reihe entwickelst, dann wirst du auf die Zinsformel stoßen. Dort findet sich die Laufzeit im Exponent. Das musst du anschließend auf die Laufzeit auflösen (was mittel logarithmieren geht).

(Einem Informationsangebot zu Finanzfragen, welches die Zinsformel nicht kennt, würde ich allerdings nur wenig Vertrauen entgegenbringen ... )

[Bolitho]

Danke für den Hinweis, kbr.

Auch wenn das dein Vertrauen nicht stärken wird, ich komme da nicht drauf. Zinseszins ist bekannt, Auflösen auch, Logarithmieren kann ich mir erschließen. Dennoch:

Die Zinsformel hilft hier mMn nicht. Ich suche nicht nach der Laufzeit, nach der ein bestimmter Betrag mit Zinseszins angespart ist. Ich suche nach der Laufzeit bis zur Rückzahlung des Investments bei sich erhöhenden Rückzahlraten:

Beispiel Zins:
angelegtes Kapital 100 ´, Zins 5%
nach 1 Jahr: Kapital 105 - Zinsen 5
nach 2 Jahren: Kapital 110,25 - Zinsen 5,25
....

Beispiel Dividenden:
angelegtes Kapital 100, Dividende 5%, Dividendensteigerung 10%
nach 1 Jahr: Auszahlung Dividende 5
nach 2 Jahren: Auszahlung Dividende 5,5
...

[pillmuncher]

Doch, da brauchst du ebenfalls die Zinsformel, nur wendest du sie auf die Dividende an, nicht das Kapital.

Code: Alles auswählen

$ python3
Python 3.6.6 (default, Oct  7 2018, 22:15:25) 
[GCC 8.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> def f(kapital, dividende, steigerung, jahre):
...     return kapital * (dividende / 100) * (1 + (steigerung / 100)) ** (jahre - 1)
... 
>>> f(100, 5, 10, 1)
5.0
>>> f(100, 5, 10, 2)
5.5
>>> f(100, 5, 10, 3)
6.050000000000001
>>> f(100, 5, 10, 4)
6.655000000000002

Hier sieht man auch schön, dass man Geldbeträge nicht durch IEEE-754-Fließkommazahlen repräsentieren sollte. Schau dir das decimal-Modul in der Standardbibliothek an.

[Bolitho]

Danke, pillmuncher. Mein Kopf ist heute scheinbar dicht, ich begreife das nicht. Ich bekomme mit der Umstellung deiner Formel ausgerechnet, nach wie viel Jahren die Dividende eine bestimmte Höhe erreich hat. Also 6,05 nach 2 Steigerungen. Aber ich komme nicht drauf, wie ich die Zeit bis zur Summe aller Dividenden in Höhe des investierten Betrags raus bekomme. ... Aber vielleicht ist mein Kopf morgen klarer.

decimal kenne und nutze ich im Projekt. Trotzdem danke für den Hinweis. Hier geht es um ein stark vereinfachtes Beispiel.

Übrigens ist die Seite online, zwar mit meinem Code, aber es läuft und muss nicht immer fancy sein.
https://divipedia.de/dividendenstrategie/payback/

[pillmuncher]

So vielleicht?

Code: Alles auswählen

>>> from itertools import count
>>> def g(kapital, dividende, steigerung):
...     dividenden = 0
...     for i in count(1):
...         dividenden += f(kapital, dividende, steigerung, i)
...         if dividenden >= kapital:
...             return i
... 
>>> g(100, 5, 10)
12

Du müsstest allerdings noch die Inflation mit einrechnen, sonst verlierst du Geld.

[Bolitho]

okay, klar. Ich hatte gestern versucht das ganze ohne for-Loop zu lösen, aber so ist es schon mal kürzer als meine Lösung oben. Thx.

Code: Alles auswählen

from itertools import count

def payback(kaufpreis, dividende, steigerung):
    dividenden = 0
    for jahre in count(1):
        dividenden += kaufpreis * (dividende / 100) * (1 + (steigerung / 100)) ** (jahre - 1)
        if dividenden >= kaufpreis:
            return jahre

print(payback(100, 5, 10))

Code: Alles auswählen

def payback(kaufpreis, dividende, steigerung):
    jahre, dividenden = 0, 0
    while dividenden < kaufpreis:
        dividenden += dividende
        jahre += 1
        dividende += dividende * steigerung / 100
    return jahre

print(payback(100, 5, 10)))

... und es geht hier um Code für ein erstes Screening, um interessante Aktien zu finden oder seine Investments neu zu bewerten. Inflation kann also vernachlässigt werden, ich darf nur nicht davon ausgehen, dass ich nach x Jahren dann die gleiche Kaufkraft zurückhabe.

[kbr]

Die Summe der Dividenden über die Laufzeit zu ermitteln, erfolgt ähnlich der Zinsberechnung.

Sei d das eingesetzte Kapital, p die Dividende (als Faktor), f der Steigerungsfaktor der Dividende und j die Laufzeit.

Dann gilt für die Auszahlungen pro Jahr:

a(1) = dp
a(2) = dpf
a(3) = dpff

a(j) = dpf^(j-1)

und für die kumulierten Auszahlungen:

A(j) = dp ∑ f^i # für i=0 bis j-1

bzw:

Code: Alles auswählen

d = 100  # eingesetztes Kapital
p = 0.05 # Dividende
f = 1.1  # Dividendensteigerung
j = 1    # Laufzeit

print(d * p * sum(f ** i for i in range(0, j)))

Ob man das geschickt nach j auflösen kann, weiß ich jetzt nicht.
Unabhängig davon kann man die Aufgabe aber noch komplizierter machen durch die Annahme, dass das Kapital per Kredit beschafft wurde.
Oder auch den Inflationsausgleich berücksichtigen (wie pillmuncher schon geschrieben hat).

[kbr]

@Bolitho: ohne Schleife bekomme ich das auch nicht hin – nur etwas kompakter, wobei sich das eingesetzte Kapital rauskürzt (d.h. die Laufzeit ist nur von p und f abhängig):

Code: Alles auswählen

p = 0.05 # Dividende
f = 1.1  # Dividendensteigerung
k = 0    # kumulierter Steigerungsfaktor
i = 0    # erforderliche Laufzeit für kumulierte Ausschüttung > eingesetztes Kapital 

while 1 / p > k:
    k += f**i
    i += 1
print(i)

[Sirius3]

@kbr: die Schleife ist eine geometrische Reihe mit der Lösung k = (f ** j -1) / (f - 1)
Das läßt sich dann mit 1/p gleichsetzen und nach j auflösen: j = log(1 + (f - 1)/p) / log(f)

[kbr]

@Sirius3: prima, das hatte ich nicht mehr in Erinnerung und die Formelsammlung hatte ich auch im Regal stehen gelassen. Dann ist es ja doch noch ein Einzeiler geworden.