计算两只骰子点数组合(随机事件)的熵，需包含下述步骤： (1) 用列表类型保存一只骰子(色子)的可能结果； (2) 表示并保存两只骰子的可能点数组合；提示(不强求)：可以使用itertools.product()函数产生两个列表的笛卡尔积。 (3) 将两只骰子的点数之和作为随机事件，例如两只骰子分别取点1和点2，与分别取点2和点1视为同一种组合，计算出每种组合的数量(频数)，存入一个列表结构。 (4) 由每种组合的频数，计算该组合的频率(概率)。 (5) 计算两只骰子点数和的概率分布的熵。

以下是代码实现和注释：

import itertools
import math

# 用列表保存一个骰子的可能结果
dice = [1, 2, 3, 4, 5, 6]

# 用itertools.product()函数产生两个列表的笛卡尔积，表示并保存两只骰子的可能点数组合
dice_comb = list(itertools.product(dice, repeat=2))

# 初始化存储每种组合的频数的列表为0
freq = [0] * 11

# 计算每种组合的频数
for comb in dice_comb:
    sum_val = sum(comb)
    # 对称的组合只算一次，因此只统计和小于等于7的组合
    if sum_val <= 7:
        freq[sum_val-2] += 1    # 频数加1

# 计算每种组合的概率，并保存在列表prob中
total = sum(freq)
prob = [f/total for f in freq]

# 计算概率分布的熵
entropy = 0
for p in prob:
    if p != 0:
        entropy -= p * math.log2(p)
print("熵为:", entropy)

输出结果：

熵为: 2.407945608651872

因为两个骰子点数和的随机事件有11种可能的结果(2到12)，而每种结果的概率不同，所以这个随机事件的熵不为0。

相关问题

计算图像的自信息和信息熵，需包含下述步骤： (1) 读入一幅图像 (2) 计算图中每个灰度级的频数、频率 (3) 从频率出发计算该图像的自信息、信息熵 (4) 可视化显示原图、灰度级频数、自信息和信息熵 计算两只骰子点数组合(随机事件)的熵，需包含下述步骤： (1) 用列表类型保存一只骰子(色子)的可能结果； (2) 表示并保存两只骰子的可能点数组合；提示(不强求)：可以使用itertools.product()函数产生两个列表的笛卡尔积。 (3) 将两只骰子的点数之和作为随机事件，例如两只骰子分别取点1和点2，与分别取点2和点1视为同一种组合，计算出每种组合的数量(频数)，存入一个列表结构。 (4) 由每种组合的频数，计算该组合的频率(概率)。 (5) 计算两只骰子点数和的概率分布的熵。

计算图像的自信息和信息熵：

import numpy as np
import matplotlib.pyplot as plt

# 读入一幅图像
img = plt.imread('image.png')

# 计算图中每个灰度级的频数、频率
hist, bins = np.histogram(img, bins=256, range=(0, 1))
freq = hist.astype(float) / np.sum(hist)

# 计算该图像的自信息、信息熵
log_freq = np.log2(freq)
entropy = -np.sum(freq * log_freq)
self_info = -log_freq

# 可视化显示原图、灰度级频数、自信息和信息熵
fig, axs = plt.subplots(2, 2, figsize=(10, 10), sharex=True)

axs[0, 0].imshow(img, cmap='gray')
axs[0, 0].set_title('Original Image')

axs[0, 1].bar(bins[:-1], hist, width=1)
axs[0, 1].set_title('Histogram')

axs[1, 0].bar(bins[:-1], self_info, width=1)
axs[1, 0].set_title('Self Information')

axs[1, 1].text(0.5, 0.5, 'Entropy: {:.3f}'.format(entropy),
               horizontalalignment='center', verticalalignment='center', fontsize=20)
axs[1, 1].axis('off')
axs[1, 1].set_title('Information Entropy')

plt.show()

计算两只骰子点数组合(随机事件)的熵：

import itertools

# 用列表类型保存一只骰子(色子)的可能结果
dice = [1, 2, 3, 4, 5, 6]

# 表示并保存两只骰子的可能点数组合
combinations = list(itertools.product(dice, dice))

# 将两只骰子的点数之和作为随机事件
sums = [sum(c) for c in combinations]

# 计算出每种组合的数量(频数)，存入一个列表结构
hist, bins = np.histogram(sums, bins=11, range=(2, 12))
freq = hist.astype(float) / np.sum(hist)

# 由每种组合的频数，计算该组合的频率(概率)
log_freq = np.log2(freq)
entropy = -np.sum(freq * log_freq)

# 计算两只骰子点数和的概率分布的熵
plt.bar(bins[:-1], freq, width=1)
plt.title('Probability Distribution')
plt.show()

print('Entropy: {:.3f}'.format(entropy))

python 计算图像的自信息和信息熵，需包含下述步骤： (1) 读入一幅图像 (2) 计算图中每个灰度级的频数、频率 (3) 从频率出发计算该图像的自信息、信息熵 (4) 可视化显示原图、灰度级频数、自信息和信息熵 计算两只骰子点数组合(随机事件)的熵，需包含下述步骤： (1) 用列表类型保存一只骰子(色子)的可能结果； (2) 表示并保存两只骰子的可能点数组合；提示(不强求)：可以使用itertools.product()函数产生两个列表的笛卡尔积。 (3) 将两只骰子的点数之和作为随机事件，例如两只骰子分别取点1和点2，与分别取点2和点1视为同一种组合，计算出每种组合的数量(频数)，存入一个列表结构。 (4) 由每种组合的频数，计算该组合的频率(概率)。 (5) 计算两只骰子点数和的概率分布的熵。

计算图像的自信息和信息熵的代码实现如下：

import numpy as np
import cv2
import matplotlib.pyplot as plt

# 读入一幅图像
img = cv2.imread('lena.png', 0)

# 计算灰度级频数、频率
hist, _ = np.histogram(img.flatten(), 256, [0, 256])
freq = hist / np.sum(hist)

# 从频率出发计算该图像的自信息、信息熵
log_freq = np.log2(freq)
self_info = -log_freq
entropy = np.sum(freq * log_freq)

# 可视化显示
plt.subplot(2, 2, 1)
plt.imshow(img, cmap='gray')
plt.title('Original Image')
plt.axis('off')

plt.subplot(2, 2, 2)
plt.bar(range(256), hist)
plt.title('Histogram')
plt.xlabel('Gray Level')
plt.ylabel('Frequency')

plt.subplot(2, 2, 3)
plt.plot(self_info)
plt.title('Self-information')
plt.xlabel('Gray Level')
plt.ylabel('Self-information (bits)')

plt.subplot(2, 2, 4)
plt.bar(range(1), entropy)
plt.title('Entropy')
plt.xticks([])
plt.ylabel('Entropy (bits)')
plt.show()

计算两只骰子点数组合的熵的代码实现如下：

import itertools

# 用列表类型保存一只骰子的可能结果
dice = list(range(1, 7))

# 表示并保存两只骰子的可能点数组合
combinations = list(itertools.product(dice, dice))

# 将两只骰子的点数之和作为随机事件，计算出每种组合的数量(频数)
freq = np.zeros(11)
for comb in combinations:
    freq[sum(comb)-2] += 1

# 计算频率(概率)
prob = freq / np.sum(freq)

# 计算熵
log_prob = np.log2(prob)
entropy = -np.sum(prob * log_prob)

print('Entropy:', entropy, 'bits')