Implementiert in Python, nachdem die Phänomene verstanden wurden, dass verschiedene Wahrscheinlichkeitsverteilungen auftreten

Einführung

Nach dem Studium der Wahrscheinlichkeitstheorie und der Statistik wurden verschiedene [Wahrscheinlichkeitsverteilung](https://ja.wikipedia.org/wiki/probability Distribution) wird angezeigt, und es gibt so viele, dass Sie sich nicht entscheiden können, welche Art von Distribution in welcher Situation verwendet werden soll.

Welche Wahrscheinlichkeitsverteilung den Wert von [Wahrscheinlichkeitsvariable](https://ja.wikipedia.org/wiki/probability variable) in einem natürlich vorkommenden Phänomen erklären kann, hängt vom Phänomen ab.

In diesem Artikel werde ich versuchen, die Verteilung zu zeichnen, indem ich das Phänomen simuliere, dass verschiedene Wahrscheinlichkeitsverteilungen mit Python auftreten.

Selbst wenn Sie den Ursprung der Verteilung nicht kennen, können Sie mithilfe des scipy.stats-Moduls von scipy problemlos verschiedene Wahrscheinlichkeitsverteilungen implementieren. Zunächst halte ich es jedoch für sinnvoll, zu wissen, unter welchen Umständen und wie eine solche Verteilung erstellt wird.

Hier werden wir es also nur mit Pythons Zufallsmodul und Numpy implementieren.

Verwenden Sie das Zufallsmodul, um eine nach der anderen zu randomisieren, und numpy, um eine Menge gleichzeitig zu randomisieren. (Grafik ist matplotlib)

Verwenden Sie dann scipy.stats, um die Ergebnisse zu vergleichen. Wenn Sie die Bedeutung der Verteilung nicht verstehen, sollten die Ergebnisse übereinstimmen.

Ich werde nicht im Detail erklären, wie man scipy.stats verwendet, da es in verschiedenen Artikeln wie diesem Artikel https://qiita.com/supersaiakujin/items/71540d1ecd60ced65add geschrieben ist.

Grundsätzlich ist die Wahrscheinlichkeitsverteilung [diskrete Wahrscheinlichkeitsverteilung](https://ja.wikipedia.org/wiki/diskrete Wahrscheinlichkeitsverteilung) und kontinuierliche Wahrscheinlichkeitsverteilung. Es ist in zwei Typen unterteilt (Wahrscheinlichkeitsverteilung), und die Implementierungsmethode unterscheidet sich geringfügig.

Der Hauptunterschied besteht beispielsweise darin, dass die diskrete Wahrscheinlichkeitsverteilung die Wahrscheinlichkeitsverteilung nach [Wahrscheinlichkeitsmassenfunktion](https://ja.wikipedia.org/wiki/Probability Mass Function) (PMF) zeigt, während die kontinuierliche Wahrscheinlichkeitsverteilung Zeigt die Wahrscheinlichkeitsverteilung in der [Wahrscheinlichkeitsdichtefunktion](https://ja.wikipedia.org/wiki/Probability Density Function) (PDF) an.

Die hier erläuterte Wahrscheinlichkeitsverteilung ist

** Diskrete Wahrscheinlichkeitsverteilung **

• [Biterm-Distribution](https://ja.wikipedia.org/wiki/binary Distribution)
• [Bernouy-Distribution](https://ja.wikipedia.org/wiki/Bernouy Distribution)
• [Geometrische Verteilung](https://ja.wikipedia.org/wiki/Geometric Distribution)
• [Negative Binomialverteilung](https://ja.wikipedia.org/wiki/negative Binomialverteilung)
• Poisson-Verteilung

** Kontinuierliche Wahrscheinlichkeitsverteilung **

• [Kontinuierliche Gleichverteilung](https://ja.wikipedia.org/wiki/Kontinuierliche Gleichverteilung)
• Exponentialverteilung
• Normalverteilung
• [Kai-Quadrat-Verteilung](https://ja.wikipedia.org/wiki/Kai-square Verteilung)
• [Beta-Distribution](https://ja.wikipedia.org/wiki/Beta Distribution)

Diskrete Wahrscheinlichkeitsverteilung

Binäre Verteilung

Bei einem Experiment, das entweder zum Erfolg oder zum Misserfolg führt, beträgt die Wahrscheinlichkeitsverteilung der Anzahl der Erfolge ** [binäre Verteilung](https://ja.wikipedia.org/wiki/binary Verteilung) ** Es ist.

Die stochastische Massenfunktion ist

P(x) = C(n,x)p^x(1-p)^{n-x}

p = Erfolgswahrscheinlichkeit n = Anzahl der Male $ C (n, x) $ wählt x aus der Funktion n Kombination aus

Wenn Sie beispielsweise in einem Spiel ein bestimmtes Monster besiegen, lassen Sie einen Gegenstand mit einer Wahrscheinlichkeit von p fallen. Wenn Sie n besiegen, wie viele Gegenstände fallen gelassen werden, sollte die Anzahl der Tropfen eine Binomialverteilung sein.

Lassen Sie uns das Ergebnis tatsächlich zufällig sehen. Hier ist n = 2000, p = 0,01 und die Anzahl der Probenahmen beträgt 10000.

import random
import numpy as np
import matplotlib.pyplot as plt
import scipy.stats
#Importieren Sie zunächst alle Module, die Sie verwenden möchten.

n_sampl = 10000 #Anzahl der Probenahmen
n = 2000 #Anzahl der zu besiegenden Monster
p = 0.01 #Wahrscheinlichkeit, einen Gegenstand fallen zu lassen
n_drop = [] #Nummer jedes Tropfens
for _ in range(n_sampl):
    #Zufällige n Stücke, um festzustellen, ob es kleiner oder gleich p ist
    drop = np.random.random(n)<=p
    n_drop.append(drop.sum()) #Speichern Sie die Anzahl der Tropfen

y = np.bincount(n_drop) #Zählen Sie die Anzahl jedes Tropfens
x = np.arange(len(y))
#Zeichnen Sie ein Balkendiagramm
plt.title('Binäre Verteilung',family='Arial Unicode MS')
plt.bar(x,y,color='#f9a7a0',ec='k')
plt.grid(ls='--')
plt.savefig('binom.png',dpi=100)
plt.close()

Als nächstes folgt die Implementierung in scipy.stats. Verwenden Sie nun .rvs () zum Randomisieren und .pmf () zum Zeichnen des Diagramms.

f = scipy.stats.binom(n,p)
plt.title('Binäre Verteilung',family='Arial Unicode MS')
h = np.bincount(f.rvs(10000))
x = np.arange(len(h))
plt.bar(x,h/n_sampl,color='#a477e2',ec='k')
plt.plot(x,f.pmf(x),'#4aec96')
plt.grid(ls='--')
plt.savefig('binom2.png',dpi=100)
plt.close()

Die mit .rvs () gezeichnete Verteilung stimmt ungefähr mit dem Diagramm in .pmf () überein und stimmt auch mit der obigen Abbildung überein. Teilen Sie hier jedoch durch die Anzahl der Stichproben, sodass die Summe 1 beträgt.

Bernoulli-Vertrieb

Wenn n = 1 in der Binomialverteilung ist, heißt es ** [Bernouy-Verteilung](https://ja.wikipedia.org/wiki/Bernouy Verteilung) **.

Wenn n = 1 ist, wird für die Wahrscheinlichkeitsmassenfunktion der Binomialverteilung gesetzt

P(x) = p^x(1-p)^{1-x}

Es wird sein. Da es einmal ausgeführt wird, ist das Ergebnis nur 0 (Erfolg) und 1 (Fehler).

Der Code ist einfacher als die Binomialverteilung.

n_sampl = 10000
p = 0.2 #Wahrscheinlichkeit, einen Gegenstand fallen zu lassen
n_drop = [] #Anzahl jedes Tropfens (0 oder 1)
for _ in range(n_sampl):
    n_drop.append(random.random()<=p) #Gibt an, ob der Zufallswert kleiner oder gleich p ist

y = np.bincount(n_drop)
x = np.arange(len(y))
plt.title('Bernoulli-Vertrieb',family='Arial Unicode MS')
plt.bar(x,y,color='#f9a7a0',ec='k')
plt.grid(ls='--')
plt.savefig('bernulli.png',dpi=100)
plt.close()

Geometrische Verteilung

Wie die Binomialverteilung ist ** [Geometrische Verteilung](https://ja.wikipedia.org/wiki/Geometric Distribution) ** eine Verteilung, die bei erfolgreichen und erfolglosen Experimenten auftritt, jedoch eine geometrische Verteilung. Die Überlegung in ist die Verteilung der Häufigkeit zum Erfolg.

Die Verteilung der Anzahl erfolgreicher Ausführungen, entweder Erfolg oder Misserfolg, ist eine geometrische Verteilung.

Wenn die Erfolgswahrscheinlichkeit p ist, ist die Wahrscheinlichkeitsmassenfunktion, wie oft erfolgreich sein soll

P(x) = p(1-p)^{x-1}

Zum Beispiel ist die Wahrscheinlichkeitsverteilung, wie viele Monster, die Gegenstände mit der Wahrscheinlichkeit p im Spiel fallen lassen, fallen gelassen werden sollen, die geometrische Verteilung.

Zufällige Dinge sind die gleichen wie im Fall der Binomialverteilung, aber dieses Mal ist die Anzahl der zu besiegenden Monster nicht festgelegt. Sie wird wiederholt, bis sie einmal erfolgreich ist.

n_sampl = 10000 #Anzahl der Probenahmen
p = 0.2 #Wahrscheinlichkeit des Fallens
kaime_drop = [] #Eine Liste, in der das Ergebnis gespeichert wird, wie oft gelöscht werden soll
for _ in range(n_sampl):
    n_kai = 1 #Anzahl der besiegten Monster
    #Wiederholen, bis erfolgreich
    while(random.random()>p):
        n_kai += 1
    #Speichert die Anzahl der nach dem Erfolg getöteten Monster
    kaime_drop.append(n_kai)

y = np.bincount(kaime_drop) #Zähle die Anzahl der Monster, die du besiegt hast
x = np.arange(len(y))
#Zeichnen Sie ein Balkendiagramm
plt.title('Geometrische Verteilung',family='Arial Unicode MS')
plt.bar(x,y,color='#f9a7a0',ec='k')
plt.grid(ls='--')
plt.savefig('geom.png',dpi=100)
plt.close()

Implementiert mit scipy

f = scipy.stats.geom(p)
plt.title('Geometrische Verteilung',family='Arial Unicode MS')
h = np.bincount(f.rvs(10000))
x = np.arange(1,len(h))
h = h[1:]
plt.bar(x,h/n_sampl,color='#a477e2',ec='k')
plt.plot(x,f.pmf(x),'#4aec96')
plt.grid(ls='--')
plt.savefig('geom2.png',dpi=100)
plt.close()

Negative Binomialverteilung

Ähnlich wie bei der geometrischen Verteilung ist ** [Negative Binomialverteilung](https://ja.wikipedia.org/wiki/Negative Binomialverteilung) ** auch eine Verteilung der Anzahl der Ausführungen, jedoch nur einmal erfolgreich Anstatt sich damit zufrieden zu geben, überlegen Sie, wie oft Sie zu einer bestimmten Anzahl von Erfolgen gelangen.

Die stochastische Massenfunktion ist

P(x) = C(k+r-1,k)(1-p)^rp^k

p = Erfolgswahrscheinlichkeit r = Häufigkeit, mit der Sie etwas erreichen möchten

Wenn r 1 ist, ist es eine geometrische Verteilung.

Wenn du zum Beispiel r Gegenstände von einem Monster willst, das Gegenstände mit einer Wahrscheinlichkeit von p fallen lässt, wie viel musst du besiegen?

Die Methode ist etwas komplizierter als die geometrische Verteilung, aber fast dieselbe.

n_sampl = 10000
p = 0.2 #Wahrscheinlichkeit des Fallens
r = 4 #Anzahl der gewünschten Erfolge
kaime_drop = []
for _ in range(n_sampl):
    n_kai = 0 #Anzahl der besiegten Monster
    n_drop = 0 #Anzahl der Tropfen
    #Besiege Monster immer und immer wieder
    while(n_drop<r):
        #Ob es ein Tropfen ist
        if(random.random()<=p):
            n_drop += 1
        n_kai += 1
    #Speichert die Anzahl der besiegten Monster nach dem Ablegen von R-Zeiten
    kaime_drop.append(n_kai)

y = np.bincount(kaime_drop)
x = np.arange(len(y))
plt.title('Negative Binomialverteilung',family='Arial Unicode MS')
plt.bar(x,y,color='#f9a7a0',ec='k')
plt.grid(ls='--')
plt.savefig('nbinom.png',dpi=100)
plt.close()

Implementiert mit scipy

f = scipy.stats.nbinom(r,p)
plt.title('Negative Binomialverteilung',family='Arial Unicode MS')
y = np.bincount(f.rvs(10000))
x = np.arange(len(h))
plt.bar(x+r,y/n_sampl,color='#a477e2',ec='k')
plt.plot(x+r,f.pmf(x),'#4aec96')
plt.grid(ls='--')
plt.savefig('nbinom2.png',dpi=100)
plt.close()

Poisson-Verteilung

Wenn ein Ereignis zu irgendeinem Zeitpunkt mit der gleichen Wahrscheinlichkeit auftritt, ist die Häufigkeit, mit der es in einem bestimmten Intervall auftritt, ** Poisson-Verteilung **.

Die stochastische Massenfunktion ist

P(x) = \frac{λ^x e^{-λ}}{x!}

λ = durchschnittliche Häufigkeit, die in einem bestimmten Intervall auftritt

Wenn ein Monster beispielsweise in einer Stunde in einem Spiel λ-mal erscheint, wie oft es tatsächlich in jeder Stunde erscheint.

n = 10000 #Anzahl der zu teilenden Zeitintervalle
λ = 8 #Durchschnittlich oft in einer bestimmten Zeit
#Zufällige Zeit zum Aufwachen
jikan = np.random.uniform(0,n,n*λ)
#Teilen Sie in 1-Stunden-Einheiten und zählen Sie, wie oft in jedem Abschnitt
kaisuu = np.bincount(jikan.astype(int))
#Zählen Sie, wie oft die Verteilung der Zeiten angezeigt wird
y = np.bincount(kaisuu)
x = np.arange(len(y))
plt.title('Poisson-Verteilung',family='Arial Unicode MS')
plt.bar(x,y,color='#f9a7a0',ec='k')
plt.grid(ls='--')
plt.savefig('poisson.png',dpi=100)
plt.close()

Es ist ein wenig kompliziert, aber es geht darum, die Zeit, in der es passiert, zufällig zu bestimmen. Da es in einem bestimmten Abschnitt ungefähr λ-mal vorkommt, sollte der Zufallsbereich der Anzahl der geteilten Abschnitte (n) entsprechen, und die Anzahl der zufälligen Zeiten sollte nλ sein.

Verwenden Sie dann np.bincount (), um zu zählen, wie oft jedes Intervall auftritt.

Außerdem verwenden wir np.bincount (), um die Verteilung der Anzahl der Vorkommen aller Intervalle zu zählen.

Implementierung in scipy

f = scipy.stats.poisson(λ)
plt.title('Poisson-Verteilung',family='Arial Unicode MS')
h = np.bincount(f.rvs(10000))
x = np.arange(len(h))
plt.bar(x,h/n,color='#a477e2',ec='k')
plt.plot(x,f.pmf(x),'#4aec96')
plt.grid(ls='--')
plt.savefig('poisson2.png',dpi=100)
plt.close()

Kontinuierliche Wahrscheinlichkeitsverteilung

Im Gegensatz zur diskreten Wahrscheinlichkeitsverteilung, die nur die Wahrscheinlichkeit einer bestimmten Zahl aufweist, wird bei einer Wahrscheinlichkeitsverteilung vom kontinuierlichen Werttyp die Wahrscheinlichkeit, eine bestimmte Zahl zu werden, zu 0, und stattdessen wird die Wahrscheinlichkeit erhalten, dass der Wert in jedem Bereich liegt. Daher wird die Wahrscheinlichkeitsverteilung durch die Wahrscheinlichkeitsdichtefunktion angezeigt.

Kontinuierliche Gleichverteilung

** [Kontinuierliche Gleichverteilung](https://ja.wikipedia.org/wiki/Kontinuierliche Gleichverteilung) ** ist eine einfache Verteilung, die eine ähnliche Wahrscheinlichkeitsverteilung nur innerhalb eines bestimmten Bereichs aufweist.

Wenn der Verteilungsbereich von a bis b reicht, ist die Wahrscheinlichkeitsdichtefunktion von x ∈ [a, b]

f(x) = \frac{1}{b-a}

Außerhalb des Bereichs ist $ f (x) = 0 $.

Es kann leicht mit np.random.uniform oder random.uniform implementiert werden.

Zum Beispiel die Geschichte eines Roulettes ohne Abschnitt. Wenn Sie den Ball auf dieses Roulette werfen, sollten Sie normalerweise denken, dass er mit der gleichen Wahrscheinlichkeit von 0 Grad bis 360 Grad stoppt.

n_sampl = 10000
a = 0 #Minimum
b = 360 #Maximal
x = np.random.uniform(a,b,n_sampl) #zufällig
#Schreiben Sie ein Histogramm
plt.title('Kontinuierliche Gleichverteilung',family='Arial Unicode MS')
plt.hist(x,50,color='#92bee1',ec='k')
plt.grid(ls='--')
plt.savefig('uniform.png',dpi=100)
plt.close()

Für eine kontinuierliche gleichmäßige Verteilung erstellt plt.hist () ein Histogramm, das die Dichte zeigt, anstatt die Zahlen mit np.bincount () zu zählen und ein Balkendiagramm zu zeichnen.

scipy hat scipy.stats.uniform, aber bei Verwendung von .rvs () scheint es sich nicht wesentlich von np.random.uniform zu unterscheiden.

In scipy.stats unterscheidet sich die Methode der Verteilungsfunktion vom diskreten Typ. Der kontinuierliche Typ ist .pdf () anstelle von .pmf ().

Wenn beim Zeichnen der Verteilung von .rvs () mit plt.hist () die Dichte = True angegeben wird, wird diese durch die Gesamtzahl der Stichproben geteilt und entspricht dem Wert von .pdf ().

f = scipy.stats.uniform(a,b)
plt.title('Kontinuierliche Gleichverteilung',family='Arial Unicode MS')
_,h,_ = plt.hist(f.rvs(10000),50,color='#ffb3d3',ec='k',density=True)
x = np.linspace(h.min(),h.max(),101)
plt.plot(x,f.pdf(x),'#4aec96')
plt.grid(ls='--')
plt.savefig('uniform2.png',dpi=100)
plt.close()

Exponentialverteilung

** Exponentialverteilung ** ist eine Verteilung, die gleichzeitig mit der Poisson-Verteilung erfolgt.

Wenn ein Ereignis zu einem bestimmten Zeitpunkt während einer bestimmten Zeit auftreten kann, ist die Zeitverteilung zwischen jedem Auftreten eine Exponentialverteilung.

Die Wahrscheinlichkeitsdichtefunktion ist

f(x) = λe^{-λx}

Wie bei der Poisson-Verteilung ist λ die durchschnittliche Häufigkeit, die in einem bestimmten Intervall auftritt.

Wenn ein Monster beispielsweise λ-mal in einer Stunde erscheint, wie lange sollte es warten, bis eines vor dem nächsten erscheint?

Die Methode ähnelt der Poisson-Verteilung, die Exponentialverteilung sieht jedoch einfacher aus.

n = 10000 #Länge der Zeit
λ = 10 #Durchschnittlich oft pro Stunde
t = np.random.uniform(0,n*λ,n) #Zufällige Zeit zum Aufwachen
t = np.sort(t) #Sortierung
x = t[1:]-t[:-1] #Zeitunterschied
#Zeichnen Sie ein Histogramm
plt.title('Exponentialverteilung',family='Arial Unicode MS')
plt.hist(x,50,color='#92bee1',ec='k')
plt.grid(ls='--')
plt.savefig('expon.png',dpi=100)
plt.close()

Implementiert mit scipy

f = scipy.stats.expon(0,λ)
plt.title('Exponentialverteilung',family='Arial Unicode MS')
_,h,_ = plt.hist(f.rvs(10000),50,color='#ffb3d3',ec='k',density=True)
x = np.linspace(h.min(),h.max(),101)
plt.plot(x,f.pdf(x),'#4aec96')
plt.grid(ls='--')
plt.savefig('expon2.png',dpi=100)
plt.close()

Normalverteilung

** Normalverteilung ** oder ** [Gaußsche Verteilung](https://ja.wikipedia.org/wiki/Gaußsche Verteilung) ** Ist die häufigste Verbreitung, so ist es die häufigste Verbreitung in der Welt.

Die Normalverteilung kann in verschiedenen Situationen auftreten, aber dieses Mal werden wir die Normalverteilung versuchen, die durch die [zentrale Polbegrenzung](https://ja.wikipedia.org/wiki/Central Pole Limitation) erzeugt wird.

Wenn Sie nach der Theorie der zentralen Polgrenze den Durchschnittswert einer großen Anzahl von Wahrscheinlichkeitsvariablen nehmen, wird die Wahrscheinlichkeitsverteilung dieses Durchschnittswerts (unabhängig von der ursprünglichen Verteilung) zu einer Normalverteilung.

Die Wahrscheinlichkeitsdichtefunktion der Normalverteilung ist

f(x) = \frac{1}{\sqrt{2πσ^2}}e^{\left(-\frac{(x-μ)^2}{2σ^2}\right)}

Ich werde es mit einem unendlichen Roulette versuchen, wie im Beispiel einer kontinuierlichen gleichmäßigen Verteilung, aber dieses Mal werde ich die Verteilung des Durchschnittswerts der Ergebnisse von 100 mal betrachten.

n_sampl = 10000
n = 100
a,b = 0,360
x = np.random.uniform(a,b,[n_sampl,n]).mean(1)
plt.title('Normalverteilung',family='Arial Unicode MS')
plt.hist(x,50,color='#92bee1',ec='k')
plt.grid(ls='--')
plt.savefig('norm.png',dpi=100)
plt.close()

Als nächstes werden wir eine Normalverteilung in scipy.stats implementieren, aber zuerst müssen wir berechnen, um den Mittelwert und die Standardabweichungen abzugleichen.

Der Mittelwert der kontinuierlichen Gleichverteilung ist $ \ frac {b + a} {2} $, und die Standardabweichung ist $ \ frac {(ba) ^ 2} {12} $, aber das Gesetz der Mehrheit //ja.wikipedia.org/wiki/ Mehrheitsgesetz) Nach $ n $ beträgt die Standardabweichung des Versuchsergebnisses $ \ frac {1} {\ sqrt {n}} $.

μ = (a+b)/2 #Durchschnittswert μ berechnen
σ = np.sqrt((b-a)**2/12/n) #Berechnen Sie die Standardabweichung σ
f = scipy.stats.norm(μ,σ)
plt.title('Normalverteilung',family='Arial Unicode MS')
_,h,_ = plt.hist(f.rvs(10000),50,color='#ffb3d3',ec='k',density=True)
x = np.linspace(h.min(),h.max(),101)
plt.plot(x,f.pdf(x),'#4aec96')
plt.grid(ls='--')
plt.savefig('norm2.png',dpi=100)
plt.close()

Chi-Quadrat-Verteilung

Wenn Sie eine Wahrscheinlichkeitsvariable ausführen, die k-mal einer Normalverteilung folgt, die Summe der Quadrate

\sum_{i=1}^{k}x_i^2

Die Verteilung von ist [Kai-Quadrat-Verteilung](https://ja.wikipedia.org/wiki/Kai-square Verteilung). Es hat nichts mit [Kaini](https://dic.pixiv.net/a/ Kai Ni) </ s> zu tun

f(x) = \frac{x^{k/2-1}e^{-x/2}}{\,2^{k/2} \Gamma(k/2)}

n_sampl = 10000
k = 5
randn = np.random.randn(n_sampl,k)
x = (randn**2).sum(1)
plt.title('Chi-Quadrat-Verteilung',family='Arial Unicode MS')
plt.hist(x,50,color='#92bee1',ec='k')
plt.grid(ls='--')
plt.savefig('chi2.png',dpi=100)
plt.close()

f = scipy.stats.chi2(k)
plt.title('Chi-Quadrat-Verteilung',family='Arial Unicode MS')
_,h,_ = plt.hist(f.rvs(10000),50,color='#ffb3d3',ec='k',density=True)
x = np.linspace(h.min(),h.max(),101)
plt.plot(x,f.pdf(x),'#4aec96')
plt.grid(ls='--')
plt.savefig('chi22.png',dpi=100)
plt.close()

f(x) = \frac{x^{α-1}(1-x)^{β-1}}{B(α,β)}

n_sampl = 10000 #Anzahl der Probenahmen
n_bin = 50 #Anzahl der zu teilenden Abschnitte
n = 4 #Jederzeit
k = 3 #Anzahl der Erfolge
p = [] #Liste zum Speichern von Abschnittsnummern
x = (np.arange(n_bin)+0.5)/n_bin #Wahrscheinlichkeitszentrum für jeden Abschnitt(0.01, 0.03, 0.05, ..., 0.99)
i_shikou = 0 #Anzahl der Versuche
while(i_shikou<n_sampl):
    rand = np.random.random(n) #Zufallszahlen, die Erfolg oder Misserfolg bestimmen
    for i in range(n_bin):
        #Anzahl der Erfolge bei der Wahrscheinlichkeit dieses Abschnitts
        if((rand<=x[i]).sum()==k):
            #Speichern Sie die Abschnittsnummer, wenn sie mit einer bestimmten Nummer übereinstimmt
            p.append(i)
            i_shikou += 1

y = np.bincount(p)
plt.title('Beta-Distribution',family='Arial Unicode MS')
plt.bar(x,y,width=1/n_bin,color='#92bee1',ec='k')
plt.grid(ls='--')
plt.savefig('beta.png',dpi=100)
plt.close()

α = k+1 # 4
β = n-k+1 # 2
f = scipy.stats.beta(α,β)
plt.title('Beta-Distribution',family='Arial Unicode MS')
plt.hist(f.rvs(10000),50,color='#ffb3d3',ec='k',density=True)
x = np.linspace(0,1,101)
plt.plot(x,f.pdf(x),'#4aec96')
plt.grid(ls='--')
plt.savefig('beta2.png',dpi=100)
plt.close()