Python Foundations-2: Beginner Probability and Statistics Problems for Machine Learning

# Python code for basic probability calculation
def calculate_probability(event_outcomes, total_outcomes):
    probability = event_outcomes / total_outcomes
    return probability

# Example usage
even_numbers = 3  # Outcomes: 2, 4, 6
total_sides = 6  # A six-sided die
result = calculate_probability(even_numbers, total_sides)
print(f"Probability of rolling an even number: {result}")

# Python code for mean calculation
def calculate_mean(data):
    mean_value = sum(data) / len(data)
    return mean_value

# Example usage
dataset = [10, 15, 20, 25, 30]
mean_result = calculate_mean(dataset)
print(f"Mean of the dataset: {mean_result}")

# Python code for median calculation
def calculate_median(data):
    sorted_data = sorted(data)
    n = len(sorted_data)
    median_value = (sorted_data[n // 2 - 1] + sorted_data[n // 2]) / 2 if n % 2 == 0 else sorted_data[n // 2]
    return median_value

# Example usage
data_values = [12, 18, 24, 32, 41]
median_result = calculate_median(data_values)
print(f"Median of the dataset: {median_result}")

# Python code for standard deviation calculation
import math

def calculate_standard_deviation(data):
    mean_value = calculate_mean(data)
    deviations = [x - mean_value for x in data]
    squared_deviations = [deviation ** 2 for deviation in deviations]
    variance = sum(squared_deviations) / len(data)
    std_deviation = math.sqrt(variance)
    return std_deviation

# Example usage
data_points = [5, 8, 12, 15, 20]
std_deviation_result = calculate_standard_deviation(data_points)
print(f"Standard Deviation of the dataset: {std_deviation_result}")

# Python code for probability distribution
def coin_toss_probability_distribution():
    outcomes = ['Heads', 'Tails']
    probability_heads = 0.5
    probability_tails = 0.5
    distribution = {'Heads': probability_heads, 'Tails': probability_tails}
    return distribution

# Example usage
coin_distribution = coin_toss_probability_distribution()
print("Coin Toss Probability Distribution:")
for outcome, probability in coin_distribution.items():
    print(f"{outcome}: {probability}")

# Python code for correlation calculation
def calculate_correlation(x, y):
    n = len(x)
    mean_x, mean_y = calculate_mean(x), calculate_mean(y)
    numerator = sum((xi - mean_x) * (yi - mean_y) for xi, yi in zip(x, y))
    denominator_x = math.sqrt(sum((xi - mean_x) ** 2 for xi in x))
    denominator_y = math.sqrt(sum((yi - mean_y) ** 2 for yi in y))
    correlation = numerator / (denominator_x * denominator_y)
    return correlation

# Example usage
variable_x = [2, 4, 6, 8, 10]
variable_y = [1, 3, 5, 7, 9]
correlation_result = calculate_correlation(variable_x, variable_y)
print(f"Correlation Coefficient: {correlation_result}")

# Python code for probability combinations
import math

def calculate_combinations(n, k):
    combinations = math.factorial(n) / (math.factorial(k) * math.factorial(n - k))
    return int(combinations)

# Example usage
total_elements = 5
chosen_elements = 2
combinations_result = calculate_combinations(total_elements, chosen_elements)
print(f"Number of Combinations: {combinations_result}")

# Python code for Bayes' theorem application
def bayes_theorem(prior, likelihood, evidence):
    posterior = (prior * likelihood) / evidence
    return posterior

# Example usage
prior_probability = 0.3
likelihood_given_event = 0.7
evidence_probability = 0.5
posterior_probability = bayes_theorem(prior_probability, likelihood_given_event, evidence_probability)
print(f"Updated Posterior Probability: {posterior_probability}")

# Python code for simulating a random variable
import random

def simulate_die_rolls(num_rolls):
    outcomes = [random.randint(1, 6) for _ in range(num_rolls)]
    return outcomes

# Example usage
num_simulations = 1000
simulation_results = simulate_die_rolls(num_simulations)
probability_of_six = simulation_results.count(6) / num_simulations
print(f"Simulated Probability of

# Python code for binomial distribution
import math

def calculate_binomial_distribution(n, k, p):
    q = 1 - p
    binomial_coefficient = math.factorial(n) / (math.factorial(k) * math.factorial(n - k))
    probability = binomial_coefficient * (p ** k) * (q ** (n - k))
    return probability

# Example usage
num_trials = 5
successes = 2
success_probability = 0.3
binomial_prob = calculate_binomial_distribution(num_trials, successes, success_probability)
print(f"Probability of {successes} successes in {num_trials} trials: {binomial_prob}")