python打开figure对象_Matplotlib：使用figure对象初始化p

可以使用Matplotlib库中的`plt.figure()`函数来创建一个新的`Figure`对象，然后将其传递给`Axes`对象的构造函数来初始化一个新的`plot`。

以下是一个简单的例子：

import matplotlib.pyplot as plt

# 创建一个新的Figure对象
fig = plt.figure()

# 将Figure对象传递给Axes对象的构造函数
ax = plt.axes()

# 在Axes对象上绘制一条线
ax.plot([1, 2, 3, 4])

# 显示图形
plt.show()

在这个例子中，我们首先使用`plt.figure()`函数创建了一个新的`Figure`对象，然后将其传递给`plt.axes()`函数来创建一个新的`Axes`对象。最后，我们在`Axes`对象上绘制了一条线，并使用`plt.show()`函数显示图形。

需要注意的是，如果不指定`plt.axes()`函数的参数，它会自动选择默认的Axes对象。如果您想要同时绘制多个子图，可以使用`plt.subplots()`函数来创建一个包含多个`Axes`对象的网格。

相关问题

python使用matplotlib绘制简易计算器

首先需要导入matplotlib库和numpy库：

import matplotlib.pyplot as plt
import numpy as np

接着，定义计算器上的按钮和显示屏的位置：

# 定义按钮位置和尺寸
btns = {
    '7': [0, 0],
    '8': [1, 0],
    '9': [2, 0],
    '/': [3, 0],
    '4': [0, 1],
    '5': [1, 1],
    '6': [2, 1],
    '*': [3, 1],
    '1': [0, 2],
    '2': [1, 2],
    '3': [2, 2],
    '-': [3, 2],
    '0': [0, 3],
    '.': [1, 3],
    '=': [2, 3],
    '+': [3, 3],
}
# 定义显示屏位置和尺寸
disp = [0, 4, 4, 1]

然后，定义按钮的点击事件处理函数，以及计算器上的操作：

# 定义按钮点击事件处理函数
def button_click(event):
    global disp_text
    btn = event.inaxes.title.get_text()
    if btn == 'C':  # 清空
        disp_text = ''
    elif btn == '=':  # 计算结果
        try:
            disp_text = str(eval(disp_text))
        except:
            disp_text = 'Error'
    else:  # 拼接数字和操作符
        disp_text += btn
    # 更新显示屏
    display.set_text(disp_text)

# 初始化显示屏文字
disp_text = ''
# 定义计算器上的操作
operations = ['7', '8', '9', '/', '4', '5', '6', '*', '1', '2', '3', '-', '0', '.', '=', '+', 'C']

接着，创建一个图形窗口并添加显示屏和按钮：

# 创建图形窗口
fig, ax = plt.subplots(figsize=(8, 8))
# 隐藏坐标轴
plt.axis('off')
# 添加显示屏
display = plt.text(disp[0], disp[1], disp_text, ha='right', va='top', fontsize=20)
# 添加按钮
for btn, pos in btns.items():
    if btn == 'C':
        color = 'orange'
    elif btn == '=':
        color = 'green'
    else:
        color = 'gray'
    rect = plt.Rectangle((pos[0], pos[1]), 1, 1, color=color)
    ax.add_patch(rect)
    plt.text(pos[0] + 0.5, pos[1] + 0.5, btn, ha='center', va='center', fontsize=20)
    rect.set_picker(True)
    rect.set_pickradius(5)
    rect.set_alpha(0.7)
    rect.set_linewidth(0)
    rect.set_edgecolor('none')
    ax.figure.canvas.mpl_connect('pick_event', button_click)

最后，显示图形窗口：

plt.show()

完整代码如下：

import matplotlib.pyplot as plt
import numpy as np

# 定义按钮位置和尺寸
btns = {
    '7': [0, 0],
    '8': [1, 0],
    '9': [2, 0],
    '/': [3, 0],
    '4': [0, 1],
    '5': [1, 1],
    '6': [2, 1],
    '*': [3, 1],
    '1': [0, 2],
    '2': [1, 2],
    '3': [2, 2],
    '-': [3, 2],
    '0': [0, 3],
    '.': [1, 3],
    '=': [2, 3],
    '+': [3, 3],
}
# 定义显示屏位置和尺寸
disp = [0, 4, 4, 1]

# 定义按钮点击事件处理函数
def button_click(event):
    global disp_text
    btn = event.inaxes.title.get_text()
    if btn == 'C':  # 清空
        disp_text = ''
    elif btn == '=':  # 计算结果
        try:
            disp_text = str(eval(disp_text))
        except:
            disp_text = 'Error'
    else:  # 拼接数字和操作符
        disp_text += btn
    # 更新显示屏
    display.set_text(disp_text)

# 初始化显示屏文字
disp_text = ''
# 定义计算器上的操作
operations = ['7', '8', '9', '/', '4', '5', '6', '*', '1', '2', '3', '-', '0', '.', '=', '+', 'C']

# 创建图形窗口
fig, ax = plt.subplots(figsize=(8, 8))
# 隐藏坐标轴
plt.axis('off')
# 添加显示屏
display = plt.text(disp[0], disp[1], disp_text, ha='right', va='top', fontsize=20)
# 添加按钮
for btn, pos in btns.items():
    if btn == 'C':
        color = 'orange'
    elif btn == '=':
        color = 'green'
    else:
        color = 'gray'
    rect = plt.Rectangle((pos[0], pos[1]), 1, 1, color=color)
    ax.add_patch(rect)
    plt.text(pos[0] + 0.5, pos[1] + 0.5, btn, ha='center', va='center', fontsize=20)
    rect.set_picker(True)
    rect.set_pickradius(5)
    rect.set_alpha(0.7)
    rect.set_linewidth(0)
    rect.set_edgecolor('none')
    ax.figure.canvas.mpl_connect('pick_event', button_click)

plt.show()

不用Matplotlib库 使用python实现一个matlab中的contourc算法

`contourc` 函数是 Matlab 中的一个绘制等高线的函数，并且其算法比较复杂，不过我们可以从其基本思路出发，自己实现一个类似的算法。

以下是一个 Python 实现的 `contourc` 函数，可以用于计算二维数组的等值线数据：

import numpy as np

def contourc(Z, levels=None, extent=None):
    """
    计算等值线数据

    :param Z: 二维数组，待计算的数据
    :param levels: 列表，指定等值线的值
    :param extent: 元组，指定数据的范围
    :return: 等值线数据，格式为 [(x1, y1), (x2, y2), ..., (xn, yn), -1, (x1, y1), (x2, y2), ..., (xm, ym), -1, ...]
    """
    # 定义一些常量
    MAX_NUM_LINES = 2000  # 最大等值线数量
    MAX_NUM_POINTS = 1000  # 最大等值线点数
    TINY = 1e-10  # 微小值，用于判断是否为0

    # 将数据转换为 numpy 数组，方便计算
    Z = np.asarray(Z)

    # 获取数据的范围
    if extent is None:
        xmin, xmax = 0, Z.shape[1] - 1
        ymin, ymax = 0, Z.shape[0] - 1
    else:
        xmin, xmax, ymin, ymax = extent

    # 等值线的值
    if levels is None:
        levels = np.linspace(Z.min(), Z.max(), num=10)

    # 初始化等值线数据
    lines = []
    num_lines = 0

    # 计算每个等值线的数据
    for level in levels:
        # 初始化数据
        line = np.zeros((MAX_NUM_POINTS, 2))  # 等值线上的点
        num_points = 0  # 等值线上的点的数量
        mask = np.zeros(Z.shape, dtype=bool)  # 标记已经经过的点

        # 找到等值线的起点
        for i in range(xmin, xmax):
            for j in range(ymin, ymax):
                if not mask[j, i] and abs(Z[j, i] - level) < TINY:
                    # 找到等值线的起点
                    x, y = i, j
                    line[num_points] = [x, y]
                    num_points += 1
                    mask[y, x] = True
                    break
            else:
                continue
            break

        # 如果没有起点，则跳过该等值线
        if num_points == 0:
            continue

        # 计算等值线上的点
        while True:
            if num_points >= MAX_NUM_POINTS:
                # 等值线上的点太多，跳过该等值线
                break

            # 找到相邻的等值点
            neighbors = []
            x, y = line[num_points - 1]
            if x > xmin and not mask[y, x - 1] and abs(Z[y, x - 1] - level) < TINY:
                neighbors.append((x - 1, y))
            if x < xmax - 1 and not mask[y, x + 1] and abs(Z[y, x + 1] - level) < TINY:
                neighbors.append((x + 1, y))
            if y > ymin and not mask[y - 1, x] and abs(Z[y - 1, x] - level) < TINY:
                neighbors.append((x, y - 1))
            if y < ymax - 1 and not mask[y + 1, x] and abs(Z[y + 1, x] - level) < TINY:
                neighbors.append((x, y + 1))

            # 如果没有相邻的等值点，则结束该等值线
            if len(neighbors) == 0:
                break

            # 找到距离起点最近的等值点
            min_dist = float('inf')
            for neighbor in neighbors:
                dist = (neighbor[0] - line[0, 0]) ** 2 + (neighbor[1] - line[0, 1]) ** 2
                if dist < min_dist:
                    x, y = neighbor
                    min_dist = dist

            # 将等值点加入等值线
            line[num_points] = [x, y]
            num_points += 1
            mask[y, x] = True

            # 如果等值线回到了起点，则结束该等值线
            if num_points > 2 and line[num_points - 1, 0] == line[0, 0] and line[num_points - 1, 1] == line[0, 1]:
                break

        # 如果等值线上的点太少，则跳过该等值线
        if num_points < 2:
            continue

        # 将等值线加入结果
        lines.append(line[:num_points])
        num_lines += 1

        # 如果等值线数量太多，则结束计算
        if num_lines >= MAX_NUM_LINES:
            break

    # 将等值线数据转换为指定格式
    contour_data = []
    for line in lines:
        for point in line:
            contour_data.append(tuple(point))
        contour_data.append(-1)

    return contour_data

该函数的输入为一个二维数组 `Z`，其输出为等值线的数据，格式为 `[(x1, y1), (x2, y2), ..., (xn, yn), -1, (x1, y1), (x2, y2), ..., (xm, ym), -1, ...]`，其中 `-1` 表示等值线的结束。

以下是一个示例程序，可以用于绘制等值线图：

import matplotlib.pyplot as plt

# 定义数据
x = y = np.linspace(-2, 2, 101)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X ** 2 + Y ** 2))

# 计算等值线数据
contour_data = contourc(Z)

# 绘制等值线图
plt.figure()
for i in range(len(contour_data)):
    if contour_data[i] == -1:
        continue
    x, y = contour_data[i]
    plt.scatter(x, y, color='r')
plt.show()

该程序中，使用 `contourc` 函数计算等值线数据，并使用 Matplotlib 绘制等值线图。