R Academy · Lektion

Erzeugen von Zufallsverteilungen

Ziehen Sie Stichproben aus Normal-, Gleichverteilungs-, Binomial- und Poissonverteilungen

Erzeugen von Zufallsverteilungen ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Die Verteilungsfunktionen von R

R stellt für jede Verteilung vier Funktionen bereit: r (Zufallszahlen), d (Dichte), p (kumulative Wahrscheinlichkeit) und q (Quantil). Die Funktionen r* erzeugen Zufallsstichproben.

# Pattern: r<dist>(n, param1, param2, ...)
# d<dist>(x, ...) -> density/probability
# p<dist>(q, ...) -> cumulative probability
# q<dist>(p, ...) -> quantile

# Example with normal distribution:
rnorm(5, mean = 0, sd = 1)    # 5 random draws
dnorm(0, mean = 0, sd = 1)    # density at x=0
pnorm(1.96, mean = 0, sd = 1) # P(X <= 1.96)
qnorm(0.975, mean = 0, sd = 1) # z-score for 97.5%
cat('Four functions: r, d, p, q for each distribution')

rnorm(): Normalverteilung

rnorm(n, mean, sd) erzeugt n Stichproben aus N(mean, sd²). Der Standardwert ist die Standardnormalverteilung N(0,1). Die Normalverteilung ist das Arbeitspferd der Statistik – der zentrale Grenzwertsatz erklärt ihre große Bedeutung.

set.seed(42)
# Standard normal (mean=0, sd=1)
z_scores <- rnorm(1000)
mean(z_scores)  # ~0
sd(z_scores)    # ~1

# Custom normal (IQ scores: mean=100, sd=15)
set.seed(42)
iq_scores <- rnorm(100, mean = 100, sd = 15)
mean(iq_scores)  # ~100
sd(iq_scores)    # ~15
summary(iq_scores)

# About 68% within 1 sd
mean(abs(iq_scores - 100) < 15)  # ~0.68

runif(): Gleichverteilung

runif(n, min, max) erzeugt n gleichverteilte Stichproben zwischen min und max. Alle Werte in diesem Bereich sind gleich wahrscheinlich. Standardmäßig liefert runif(n) Werte in [0, 1].

set.seed(7)
# Default: uniform on [0, 1]
u <- runif(5)
print(u)  # values in (0, 1)

# Uniform on [a, b]
temps <- runif(100, min = -10, max = 40)  # temperatures
mean(temps)   # ~15 (midpoint)
range(temps)  # should be within [-10, 40]

# Discrete simulation using floor()
dice_rolls <- floor(runif(10, min = 1, max = 7))
print(dice_rolls)  # integers 1-6
table(floor(runif(600, 1, 7)))  # roughly equal counts

rbinom(): Binomialverteilung

rbinom(n, size, prob) simuliert n Binomialexperimente, die jeweils aus size Bernoulli-Versuchen mit der Erfolgswahrscheinlichkeit prob bestehen. Verwenden Sie size=1 für Bernoulli-Ziehungen.

set.seed(123)
# 10 coin flips (prob=0.5), repeated 5 times
coin_flips <- rbinom(5, size = 10, prob = 0.5)
print(coin_flips)  # number of heads each time

# Bernoulli: single flip (size=1)
flips <- rbinom(20, size = 1, prob = 0.5)
print(flips)  # 0s and 1s
mean(flips)   # ~0.5

# Biased coin (prob=0.7)
biased <- rbinom(1000, size = 1, prob = 0.7)
mean(biased)  # ~0.7

# Many trials: normal approximation kicks in
hundred_flips <- rbinom(1000, size = 100, prob = 0.5)
mean(hundred_flips)  # ~50

rpois(): Poisson-Verteilung

rpois(n, lambda) erzeugt n Stichproben aus einer Poisson-Verteilung mit der Rate λ. Damit lassen sich Zähldaten modellieren, also Ereignisse pro Intervall: Website-Besuche pro Minute, Fehler pro Einheit oder Anrufe pro Stunde.

set.seed(5)
# Calls received per hour (average 3)
calls <- rpois(24, lambda = 3)  # 24 hours
print(calls)  # integers, mostly 1-6
mean(calls)   # ~3 (expectation = lambda)
var(calls)    # ~3 (variance = lambda for Poisson)

# Count the distribution
table(calls)

# Rare events (lambda=0.5)
rare_events <- rpois(100, lambda = 0.5)
table(rare_events)  # mostly 0s and 1s
mean(rare_events)   # ~0.5

rexp(): Exponentialverteilung

rexp(n, rate) erzeugt n Stichproben aus der Exponentialverteilung mit der angegebenen Rate. Damit lässt sich die Zeit zwischen Ereignissen modellieren. Der Mittelwert beträgt 1/rate. Die Verteilung ist gedächtnislos.

set.seed(42)
# Time between customer arrivals (rate=2 per minute)
# Mean wait time = 1/2 = 0.5 minutes
arrival_times <- rexp(100, rate = 2)
mean(arrival_times)  # ~0.5
sd(arrival_times)    # ~0.5 (mean = sd for exponential)

# Simulate a queue
cumulative_arrivals <- cumsum(rexp(10, rate = 3))
print(round(cumulative_arrivals, 3))

# Exponential CDF: P(X <= x) = 1 - exp(-rate*x)
pexp(0.5, rate = 2)   # P(wait <= 0.5 min)
mean(arrival_times <= 0.5)  # empirical estimate

sample(): Diskretes Sampling

sample(x, size, replace) zieht size Elemente aus dem Vektor x. replace=FALSE (Standard) bedeutet Ziehen ohne Zurücklegen; replace=TRUE erlaubt wiederholte Werte.

set.seed(10)
# Sample without replacement (like drawing cards)
cards <- 1:52
hand <- sample(cards, size = 5, replace = FALSE)
print(hand)  # 5 unique cards

# Sample with replacement (bootstrap)
x <- c(10, 20, 30, 40, 50)
bootstrap_sample <- sample(x, size = 5, replace = TRUE)
print(bootstrap_sample)  # may have repeats

# Simulate rolling two dice 1000 times
dice <- function() sum(sample(1:6, 2, replace = TRUE))
rolls <- replicate(1000, dice())
table(rolls) / 1000  # empirical probabilities

Gewichtetes Sampling

sample(x, size, replace, prob) verwendet Wahrscheinlichkeitsgewichte. Der Vektor prob weist jedem Element relative Wahrscheinlichkeiten zu – nützlich für nicht gleichverteilte diskrete Verteilungen.

set.seed(99)
# Loaded die: 6 is twice as likely
faces <- 1:6
weights <- c(1, 1, 1, 1, 1, 2)  # relative
norm_weights <- weights / sum(weights)

rolls <- sample(faces, size = 1000, replace = TRUE,
                prob = norm_weights)
table(rolls) / 1000
# 6 appears ~2/7 ~= 0.286 of the time

# Categorical sampling
categories <- c('A', 'B', 'C')
probs <- c(0.5, 0.3, 0.2)
sample(categories, 10, replace = TRUE, prob = probs)

rgeom() und rnbinom(): Zählverteilungen

rgeom(n, prob) zählt die Fehlschläge vor dem ersten Erfolg. rnbinom(n, size, prob) zählt die Fehlschläge vor size Erfolgen. Beide Funktionen modellieren überdisperse Zähldaten, deren Varianz größer als bei der Poisson-Verteilung ist.

set.seed(42)
# Geometric: flips until first head (prob=0.3)
# Number of FAILURES before first success
flips_until_head <- rgeom(10, prob = 0.3) + 1  # +1 for the success
print(flips_until_head)
mean(flips_until_head)  # ~1/0.3 = 3.33

# Negative binomial: overdispersed count data
# e.g., number of parasites per host
counts <- rnbinom(100, size = 2, prob = 0.4)
mean(counts)   # ~3 (theoretical: size*(1-p)/p)
var(counts)    # much larger than mean -> overdispersed

# Compare variance to Poisson with same mean
pois_counts <- rpois(100, lambda = mean(counts))
var(counts) / var(pois_counts)  # > 1

rt() und rf(): t- und F-Verteilungen

rt(n, df) erzeugt t-verteilte Stichproben mit df Freiheitsgraden. Für df → ∞ konvergiert die Verteilung gegen die Normalverteilung. rf(n, df1, df2) erzeugt F-verteilte Stichproben – das Verhältnis von Chi-Quadrat-Variablen.

set.seed(1)
# t distribution: heavier tails than normal
t_vals <- rt(1000, df = 5)
mean(t_vals)  # ~0
sd(t_vals)    # > 1 (inflated by heavy tails)

# Compare to normal
n_vals <- rnorm(1000)
# t has more extreme values (heavy tails)
sum(abs(t_vals) > 3)   # e.g., ~30
sum(abs(n_vals) > 3)   # e.g., ~3

# F distribution: used in ANOVA F-tests
f_vals <- rf(1000, df1 = 5, df2 = 20)
range(f_vals)   # always positive
mean(f_vals)    # ~df2/(df2-2) = 20/18 = 1.11

Zufallsverteilungen visualisieren

Histogramme und Dichteplots veranschaulichen die Form simulierter Verteilungen. Vergleichen Sie die empirische Dichte mit theoretischen Dichtekurven, indem Sie hist() mit einem Overlay aus curve(dnorm(...)) verwenden.

set.seed(42)
x <- rnorm(10000, mean = 5, sd = 2)

# Quick summary statistics
summary(x)
cat('Mean:', mean(x), '\n')
cat('SD:', sd(x), '\n')
cat('Skewness (should be ~0 for normal):',
    mean(((x - mean(x))/sd(x))^3), '\n')

# Empirical quantiles vs theoretical
quantile(x, c(0.025, 0.25, 0.5, 0.75, 0.975))
# Compare to theoretical:
qnorm(c(0.025, 0.25, 0.5, 0.75, 0.975),
      mean = 5, sd = 2)

Kurze Überprüfung

Testen Sie Ihr Wissen über die Zufallsverteilungsfunktionen von R.

Zusammenfassung: Zufallsverteilungen

Die wichtigsten Punkte: rnorm(n, mean, sd) für die Normalverteilung; runif(n, min, max) für die Gleichverteilung; rbinom(n, size, prob) für die Binomialverteilung; rpois(n, lambda) für Poisson-Zähldaten; rexp(n, rate) für exponentiell verteilte Wartezeiten; sample(x, size, replace) für diskretes Sampling. Verwenden Sie vor dem Erzeugen von Zufallszahlen in reproduzierbaren Analysen immer set.seed().

set.seed(42)
# Quick reference of common distributions:
rnorm(3, mean = 0, sd = 1)        # Normal
runif(3, min = 0, max = 1)        # Uniform
rbinom(3, size = 10, prob = 0.5)  # Binomial
rpois(3, lambda = 3)              # Poisson
rexp(3, rate = 1)                 # Exponential
rt(3, df = 10)                    # Student t
rf(3, df1 = 5, df2 = 20)          # F distribution
rgeom(3, prob = 0.3)              # Geometric
sample(1:10, 3, replace = TRUE)   # Discrete uniform
cat('R has 20+ built-in distributions')

Häufig gestellte Fragen

Ist die Lektion „Erzeugen von Zufallsverteilungen“ kostenlos?

Ja — der vollständige Text von „Erzeugen von Zufallsverteilungen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Erzeugen von Zufallsverteilungen“?

Ziehen Sie Stichproben aus Normal-, Gleichverteilungs-, Binomial- und Poissonverteilungen Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um R Academy zu starten?

Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Erzeugen von Zufallsverteilungen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?

Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu R Academy