🖼 人工智能学习总目录

🖼 《Python编程_从入门到实践》小结及目录

本章知识小结：

  • 1、使用matplotlib创建简单的图表
  • 2、使用plotly绘制直方图探索掷多个骰子结果

1、安装Matplotlib

1
python3 -m pip install --user matplotlib

2、绘制简单的折线图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 导入 matplotlib.pyplot 库，用于绘图
import matplotlib.pyplot as plt

# 创建一个包含输入数据的列表
input_values = [1, 2, 3, 4, 5]

# 创建一个包含平方值的列表
squares = [1, 4, 9, 16, 25]

# 内置样式（plt.style.available）
# 使用 'seaborn' 样式来美化图形
plt.style.use('seaborn')

# 创建一个图形对象和一个轴对象（默认的函数调用方法）
fig, ax = plt.subplots()

# 绘制线图，使用指定的线宽度
ax.plot(input_values, squares, linewidth=3)

# 设置图的标题，以及x轴和y轴的标签，并指定字体大小
ax.set_title("Square Numbers", fontsize=24)
ax.set_xlabel("Value", fontsize=14)
ax.set_ylabel("Square of Value", fontsize=14)

# 设置刻度标签的字体大小(x,y轴的精度)
ax.tick_params(axis='both', labelsize=14)

# 显示图形
plt.show()

折线图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 导入 matplotlib.pyplot 库，用于绘图
import matplotlib.pyplot as plt

# 创建 x 值的范围，从1到1000
x_values = range(1, 1001)

# 创建对应 x 值的平方的列表
y_values = [x**2 for x in x_values]

# 使用 'seaborn' 样式美化图形
plt.style.use('seaborn')

# 创建一个图形对象和一个轴对象（默认的函数调用方法）
fig, ax = plt.subplots()

# 绘制散点图，设置颜色映射colormap为蓝色（取决于 y 值），设置点的大小为 10
# ax.scatter(x_values, y_values, c='blue', s=10)
ax.scatter(x_values, y_values, c=y_values, cmap=plt.cm.Blues, s=10)

# 设置图的标题，以及 x 轴和 y 轴的标签，并指定字体大小
ax.set_title("Square Numbers", fontsize=24)
ax.set_xlabel("Value", fontsize=14)
ax.set_ylabel("Square of Value", fontsize=14)

# 设置刻度标签的字体大小
ax.tick_params(axis='both', which='major', labelsize=14)

# 设置每个轴的取值范围
ax.axis([0, 1100, 0, 1100000])

# 显示图形
plt.show()

散点图

1
2
# 保存图形为 'myplot.png'，并确保保存时去除多余的空白边缘
plt.savefig('myplot.png', bbox_inches='tight')

3、随机漫步

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# 导入 random 模块中的 choice 函数，用于在列表中做随机选择
from random import choice

# 定义一个名为 RandomWalk 的类
class RandomWalk:
    """A class to generate random walks."""
    
    # 初始化随机漫步的属性，默认生成5000个点
    def __init__(self, num_points=5000):
        self.num_points = num_points
        
        # 所有漫步都始于(0, 0)
        self.x_values = [0]
        self.y_values = [0]

    # 计算随机漫步的所有点
    def fill_walk(self):
    
        # 不断取步，直到漫步达到指定的长度
        while len(self.x_values) < self.num_points:
        
            # 决定前进的方向和前进的距离
            x_direction = choice([1, -1])
            x_distance = choice([0, 1, 2, 3, 4])
            x_step = x_direction * x_distance
        
            y_direction = choice([1, -1])
            y_distance = choice([0, 1, 2, 3, 4])
            y_step = y_direction * y_distance
        
            # 拒绝不产生移动的情况
            if x_step == 0 and y_step == 0:
                continue
        
            # 计算新的位置
            x = self.x_values[-1] + x_step
            y = self.y_values[-1] + y_step
        
            self.x_values.append(x)
            self.y_values.append(y)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# 导入 matplotlib.pyplot 库，用于绘图
import matplotlib.pyplot as plt

# 从 random_walk 模块中导入 RandomWalk 类
from random_walk import RandomWalk

# 持续生成新的随机漫步，只要程序处于活动状态
while True:
    # 创建一个 RandomWalk 实例，生成漫步路径包含 50,000 个点
    rw = RandomWalk(50_000)
    rw.fill_walk()

    # 绘制漫步路径上的点
    plt.style.use('classic')
    fig, ax = plt.subplots(figsize=(15, 9))
    point_numbers = range(rw.num_points)
    ax.scatter(rw.x_values, rw.y_values, c=point_numbers, cmap=plt.cm.Blues,
        edgecolors='none', s=1)

    # 强调起点和终点
    ax.scatter(0, 0, c='green', edgecolors='none', s=100)
    ax.scatter(rw.x_values[-1], rw.y_values[-1], c='red', edgecolors='none',
        s=100)

    # 移除坐标轴
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)

    # 显示图形
    plt.show()

    # 询问是否生成另一条漫步路径
    keep_running = input("Make another walk? (y/n): ")
    if keep_running == 'n':
        break

随机漫步例图

4、使用Plotly模拟掷骰子

使用Plotly包来生成交互式图标（它生成的图表会自动缩放以适合观看者的屏幕，亦可交互式向用户展示特定元素）

1
python -m pip install --user plotly

4.1 die.py

模拟一个筛子的情况，生成示例调用roll会随机生成1~6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 从 random 模块中导入 randint 函数，用于生成随机整数
from random import randint

# 定义一个名为 Die 的类
class Die:
    
    # 初始化方法，假设骰子有六个面
    def __init__(self, num_sides=6):
        self.num_sides = num_sides
        
    # 掷骰子的方法，返回一个介于1和面数之间的随机值
    def roll(self):
        return randint(1, self.num_sides)

4.2 掷骰子、分析结果、绘制直方图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# 从 plotly.graph_objs 模块中导入 Bar 和 Layout 类
from plotly.graph_objs import Bar, Layout

# 从 plotly 模块中导入 offline 函数
from plotly import offline

# 从 die 模块中导入 Die 类
from die import Die

# 创建一个六面骰子
die = Die()

# 进行一些投掷，并将结果存储在一个列表中
results = []
for roll_num in range(1000):
    result = die.roll()
    results.append(result)
    
# 分析投掷结果
frequencies = []
for value in range(1, die.num_sides+1):
    frequency = results.count(value)
    frequencies.append(frequency)
    
# 可视化结果
x_values = list(range(1, die.num_sides+1))
data = [Bar(x=x_values, y=frequencies)]

x_axis_config = {'title': 'Result'}
y_axis_config = {'title': 'Frequency of Result'}
my_layout = Layout(title='Results of rolling one D6 1000 times',
        xaxis=x_axis_config, yaxis=y_axis_config)

# 生成并保存 HTML 文件
offline.plot({'data': data, 'layout': my_layout}, filename='d6.html')

单骰子HTML例图

4.3 投掷两枚六面骰子的结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# 从 plotly.graph_objs 模块中导入 Bar 和 Layout 类
from plotly.graph_objs import Bar, Layout

# 从 plotly 模块中导入 offline 函数
from plotly import offline

# 从 die 模块中导入 Die 类
from die import Die

# 创建两个六面骰子
die_1 = Die()
die_2 = Die()

# 进行一些投掷，并将结果存储在一个列表中
results = []
for roll_num in range(1000):
    result = die_1.roll() + die_2.roll()
    results.append(result)
    
# 分析投掷结果
frequencies = []
max_result = die_1.num_sides + die_2.num_sides
for value in range(2, max_result+1):
    frequency = results.count(value)
    frequencies.append(frequency)
    
# 可视化结果
x_values = list(range(2, max_result+1))
data = [Bar(x=x_values, y=frequencies)]

x_axis_config = {'title': 'Result', 'dtick': 1}
y_axis_config = {'title': 'Frequency of Result'}
my_layout = Layout(title='Results of rolling two D6 dice 1000 times',
        xaxis=x_axis_config, yaxis=y_axis_config)

# 生成并保存 HTML 文件
offline.plot({'data': data, 'layout': my_layout}, filename='d6_d6.html')

双骰子HTML例图

4.4 一枚六面、一枚十骰子结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# 从 plotly.graph_objs 模块中导入 Bar 和 Layout 类
from plotly.graph_objs import Bar, Layout

# 从 plotly 模块中导入 offline 函数
from plotly import offline

# 从 die 模块中导入 Die 类
from die import Die

# 创建一枚六面骰子和一枚十面骰子
die_1 = Die()
die_2 = Die(10)

# 进行一些投掷，并将结果存储在一个列表中
results = []
for roll_num in range(50_000):
    result = die_1.roll() + die_2.roll()
    results.append(result)
    
# 分析投掷结果
frequencies = []
max_result = die_1.num_sides + die_2.num_sides
for value in range(2, max_result+1):
    frequency = results.count(value)
    frequencies.append(frequency)
    
# 可视化结果
x_values = list(range(2, max_result+1))
data = [Bar(x=x_values, y=frequencies)]

x_axis_config = {'title': 'Result', 'dtick': 1}
y_axis_config = {'title': 'Frequency of Result'}
my_layout = Layout(title='Results of rolling a D6 and a D10 50000 times',
        xaxis=x_axis_config, yaxis=y_axis_config)

# 生成并保存 HTML 文件
offline.plot({'data': data, 'layout': my_layout}, filename='d6_d10.html')

六面骰子+十面骰子结果例图