Summary  
This chapter covers calculating probabilities for equally likely outcomes using the classical probability formula and verifying those calculations by simulating random events and counting frequencies in code.

General domain of usage  
Game and random‐event simulation (e.g., dice rolls and coin flips)

This video introduces the classical definition of probability, focusing on scenarios where all outcomes are equally likely. It explains how to count possible outcomes using simple examples involving dice and coins, and demonstrates how to apply the classical probability formula to these situations.

The classical definition of probability is based on the idea that if all outcomes of an experiment are equally likely, the probability of an event is the ratio of the number of favorable outcomes to the total number of possible outcomes. The formula is:

**Classical Probability Formula:**  
$$
P(A) = \frac{\text{Number of favorable outcomes}}{\text{Total number of possible outcomes}}
$$

For example, if you toss a fair coin, there are two equally likely outcomes: heads or tails. The probability of getting heads is $$1/2$$. If you roll a standard six-sided die, each face (1 through 6) is equally likely, so the probability of rolling a 4 is $$1/6$$.

Let's consider another example:  
Suppose you roll a pair of dice. The total number of possible outcomes is $$6 × 6 = 36$$, since each die has 6 faces. The probability of rolling a sum of 7 is the number of outcomes where the dice add up to 7 divided by 36.

import random

# Simulate rolling a six-sided die 6000 times and calculate the frequency of each outcome
trials = 6000
outcomes = [0] * 6  # List to store counts for faces 1 through 6

for _ in range(trials):
    roll = random.randint(1, 6)
    outcomes[roll - 1] += 1

# Calculate the probability for each face
probabilities = [count / trials for count in outcomes]

for i, prob in enumerate(probabilities, start=1):
    print(f"Probability of rolling {i}: {prob:.3f}")

import unittest
import ast
import re
import io
import sys

class TestTask(unittest.TestCase):
    def test_default_values(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        ns = {}
        try:
            exec(code, ns)
            prob = ns.get('probability')
            
            is_correct = prob is not None and isinstance(prob, float) and abs(prob - 0.5) < 1e-8
        except Exception:
            is_correct = False
            prob = None
            
        _dynamic_test(
            self,
            is_correct,
            "Correctly computes the probability for a standard deck.",
            f"Expected probability to be 0.5. Got {prob}. Make sure you divide total_red by total_cards.",
        )

    def test_dynamic_values(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        # Підміняємо total_red на 13 (ніби шукаємо ймовірність витягнути одну масть)
        code = change_var(code, 'total_red', '13')
        
        ns = {}
        try:
            exec(code, ns)
            prob = ns.get('probability')
            
            # Очікувана ймовірність: 13 / 52 = 0.25
            is_correct = prob is not None and abs(prob - 0.25) < 1e-8
        except Exception:
            is_correct = False
            
        _dynamic_test(
            self,
            is_correct,
            "Probability calculation works dynamically.",
            "Failed to calculate probability dynamically. Make sure you use the formula `total_red / total_cards` instead of hardcoding the answer.",
        )

    def test_printed_output(self):
        with open('user_code.py', 'r') as f:
            code = f.read()
            
        f_io = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f_io
        try:
            exec(code, {})
        except Exception:
            pass
        finally:
            sys.stdout = sys_stdout
            
        output = f_io.getvalue()
        
        found = '0.5' in output
        
        _dynamic_test(
            self,
            found,
            "The probability is printed successfully.",
            "The result was not printed properly. Make sure to print the 'probability' variable.",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def gsub_spaces(text):
    text = re.sub(r"\s+", "", text)
    text = text.replace("'", "")
    text = text.replace('"', "")
    return text

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]
    if not assign_nodes:
        return code
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True
        
    return chr(10).join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()

test_main.py

Dive into the foundational concepts of probability theory, exploring its principles, applications, and problem-solving techniques using Python. This course blends theoretical understanding with practical coding exercises and visualizations.

A comprehensive journey through the essential concepts and applications of probability theory, with each chapter combining video explanations, Python code, and interactive practice.

Classical Probability and Counting

Solution