关于传参给另一个文件利用Qt5Agg绘制散点图的问题

有两个.py文件，文件1和文件2，文件1利用PYQT5生成一个按钮，点击后传递一个df数据框参数给文件2，文件2接收df参数后绘制散点图（散点图以Qt5Agg为底图，带滚动条），我的问题是文件2实例化单独运行没有问题，但通过文件1调用就闪退，请帮忙查找原因，代码如下
文件1代码如下：

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton
from PyQt5.QtCore import Qt
import pandas as pd
import 文件2


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Main Window")
        self.setGeometry(100, 100, 500, 500)

        button = QPushButton("传参绘图", self)
        button.setGeometry(200, 200, 120, 40)
        button.clicked.connect(self.create_scatter_plot)

    def create_scatter_plot(self):
        # 有一个数据框df
        x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        y = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
        df = pd.DataFrame({"x":x,"y":y})
        # 将数据框参数传递给另一个文件
        文件2.qt(df)




if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())

文件2代码如下：

import sys
import matplotlib
import matplotlib.pyplot as plt
matplotlib.use('Qt5Agg')    # 设置后端为Qt5
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas    # 导入Qt5Agg的FigureCanvas
from PyQt5.QtWidgets import QApplication, QMainWindow, QScrollArea, QWidget, QVBoxLayout # 导入滚动区域的Qt窗口控件
import pandas as pd

class qt(QMainWindow):
    def __init__(self, df):
        print(df)
        # 创建滚动区域的Qt窗口
        app = QApplication([])
        window = QMainWindow()
        scroll_area = QScrollArea()
        widget = QWidget()
        layout = QVBoxLayout(widget)

        # 创建Matplotlib图像
        fig, ax = plt.subplots(figsize=(40, 10))

        # 生成测试数据
        x = df['x'].tolist()
        y = df['y'].tolist()
        print(x,y)

        # 绘制散点图
        ax.scatter(x, y)

        # 将Matplotlib图像添加到布局中
        layout.addWidget(FigureCanvas(fig))

        # 设置滚动区域的布局
        scroll_area.setWidget(widget)
        window.setCentralWidget(scroll_area)

        # 显示窗口
        window.show()
        app.exec_()

# if __name__ == "__main__":
#     x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#     y = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
#     df = pd.DataFrame({"x": x, "y": y})
#     app = QApplication(sys.argv)
#     window = qt(df)
#     window.show()
#     sys.exit(app.exec_())

这是因为进入主事件循环之后，只会对这一个主窗口循环处理，调用其它的窗口的 show 方法只会闪现一下，而不会真正让其他窗口进入循环。
文件2 不需要再次调用 QApplication.exec 了，只需要用 QtCore.QEventLoop 创建一个本地事件循环：

from PyQt5.QtCore import QEventLoop
# ...
loop = QEventLoop()
window.show()
loop.exec()

引用chatgpt内容作答：
根据您提供的代码，可以看出问题可能出现在文件2中，具体原因是在文件2中实例化类 qt 的时候，您使用了新的 QApplication 对象，并在 app.exec_() 启动了新的事件循环。然而，Qt应用程序只能有一个主事件循环，当从文件1调用文件2时，两个事件循环之间发生冲突，可能导致程序闪退。

解决这个问题的方法是让文件2只负责绘制散点图的窗口而不启动新的事件循环。您可以修改文件2，将绘制散点图的部分封装在一个类中，然后在文件1中实例化这个类并将它的绘图方法调用。

文件2代码修改如下：

import sys
import matplotlib
import matplotlib.pyplot as plt
matplotlib.use('Qt5Agg')
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from PyQt5.QtWidgets import QMainWindow, QScrollArea, QWidget, QVBoxLayout
import pandas as pd

class ScatterPlotWindow(QMainWindow):
    def __init__(self, df):
        super().__init__()

        # 创建滚动区域的Qt窗口
        scroll_area = QScrollArea()
        widget = QWidget()
        layout = QVBoxLayout(widget)

        # 创建Matplotlib图像
        fig, ax = plt.subplots(figsize=(40, 10))

        # 生成测试数据
        x = df['x'].tolist()
        y = df['y'].tolist()

        # 绘制散点图
        ax.scatter(x, y)

        # 将Matplotlib图像添加到布局中
        layout.addWidget(FigureCanvas(fig))

        # 设置滚动区域的布局
        scroll_area.setWidget(widget)
        self.setCentralWidget(scroll_area)

# if __name__ == "__main__":
#     x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#     y = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
#     df = pd.DataFrame({"x": x, "y": y})
#     app = QApplication(sys.argv)
#     window = ScatterPlotWindow(df)
#     window.show()
#     sys.exit(app.exec_())

文件1代码不需要修改。

然后，您可以在文件1中导入文件2，并在 create_scatter_plot 方法中实例化 ScatterPlotWindow 类并显示窗口：

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton
from PyQt5.QtCore import Qt
import pandas as pd
from 文件2 import ScatterPlotWindow


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Main Window")
        self.setGeometry(100, 100, 500, 500)

        button = QPushButton("传参绘图", self)
        button.setGeometry(200, 200, 120, 40)
        button.clicked.connect(self.create_scatter_plot)

    def create_scatter_plot(self):
        # 有一个数据框df
        x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        y = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
        df = pd.DataFrame({"x": x, "y": y})
        # 将数据框参数传递给另一个文件
        scatter_window = ScatterPlotWindow(df)
        scatter_window.show()


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())

这样应该就可以避免冲突和闪退问题，并在文件1中调用文件2绘制散点图。

这个应该是你文件2的问题
首先，需要将matplotlib.pyplot的绘图操作放在函数__init__(self, df)中，以便在文件1中调用时进行绘图。修改如下：

def __init__(self, df):
    # 创建滚动区域的Qt窗口
    app = QApplication([])
    window = QMainWindow()
    scroll_area = QScrollArea()
    widget = QWidget()
    layout = QVBoxLayout(widget)

    # 创建Matplotlib图像
    fig, ax = plt.subplots(figsize=(40, 10))

    # 生成测试数据
    x = df['x'].tolist()
    y = df['y'].tolist()
    print(x,y)

    # 绘制散点图
    ax.scatter(x, y)

    # 将Matplotlib图像添加到布局中
    layout.addWidget(FigureCanvas(fig))

    # 设置滚动区域的布局
    scroll_area.setWidget(widget)
    window.setCentralWidget(scroll_area)

    # 显示窗口
    window.show()
    app.exec_()

其次，注释掉文件2中的if语句判断if name == "main":部分，因为在文件1中调用文件2时，不会执行这个部分。

最后，在文件2的开头添加以下代码，确保使用Qt5Agg作为matplotlib的后端。


```python
import matplotlib
matplotlib.use("Qt5Agg")

修改后的文件2代码如下所示：

import sys
import matplotlib
matplotlib.use("Qt5Agg")
import matplotlib.pyplot as plt
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from PyQt5.QtWidgets import QApplication, QMainWindow, QScrollArea, QWidget, QVBoxLayout
import pandas as pd

class qt(QMainWindow):
    def __init__(self, df):
        # 创建滚动区域的Qt窗口
        app = QApplication([])
        window = QMainWindow()
        scroll_area = QScrollArea()
        widget = QWidget()
        layout = QVBoxLayout(widget)

        # 创建Matplotlib图像
        fig, ax = plt.subplots(figsize=(40, 10))

        # 生成测试数据
        x = df['x'].tolist()
        y = df['y'].tolist()

        # 绘制散点图
        ax.scatter(x, y)

        # 将Matplotlib图像添加到布局中
        layout.addWidget(FigureCanvas(fig))

        # 设置滚动区域的布局
        scroll_area.setWidget(widget)
        window.setCentralWidget(scroll_area)

        # 显示窗口
        window.show()
        app.exec_()

```
现在，你可以尝试再次运行文件1，并调用文件2进行测试，看看是否还会闪退。

修改好的代码，测试无闪退

文件一

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton
from PyQt5.QtCore import Qt
import pandas as pd
import t9


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Main Window")
        self.setGeometry(100, 100, 500, 500)

        button = QPushButton("传参绘图", self)
        button.setGeometry(200, 200, 120, 40)
        button.clicked.connect(self.create_scatter_plot)

    def create_scatter_plot(self):
        # 有一个数据框df
        x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        y = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
        df = pd.DataFrame({"x":x,"y":y})
        # 将数据框参数传递给另一个文件
        # 修改：将文件2的实例化对象赋值给一个变量self.window，并且传递当前的QApplication对象app
        self.window = t9.qt(df, app)


if __name__ == "__main__":
    # 修改：将QApplication对象赋值给一个变量app
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())

文件2代码

import sys
import matplotlib
import matplotlib.pyplot as plt
matplotlib.use('Qt5Agg')    # 设置后端为Qt5
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas    # 导入Qt5Agg的FigureCanvas
from PyQt5.QtWidgets import QApplication, QMainWindow, QScrollArea, QWidget, QVBoxLayout # 导入滚动区域的Qt窗口控件
import pandas as pd

class qt(QMainWindow):
    def __init__(self, df, app): # 修改：增加一个参数app，接收文件1中传递过来的QApplication对象
        print(df)
        # 创建滚动区域的Qt窗口
        # 修改：注释掉创建新的QApplication对象的语句，使用文件1中传递过来的QApplication对象app
        # app = QApplication([])
        window = QMainWindow()
        scroll_area = QScrollArea()
        widget = QWidget()
        layout = QVBoxLayout(widget)

        # 创建Matplotlib图像
        fig, ax = plt.subplots(figsize=(40, 10))

        # 生成测试数据
        x = df['x'].tolist()
        y = df['y'].tolist()
        print(x,y)

        # 绘制散点图
        ax.scatter(x, y)

        # 将Matplotlib图像添加到布局中
        layout.addWidget(FigureCanvas(fig))

        # 设置滚动区域的布局
        scroll_area.setWidget(widget)
        window.setCentralWidget(scroll_area)

        # 显示窗口
        window.show()
        app.exec_()

# if __name__ == "__main__":
#     x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#     y = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
#     df = pd.DataFrame({"x": x, "y": y})
#     app = QApplication(sys.argv)
#     window = qt(df)
#     window.show()
#     sys.exit(app.exec_())

【以下回答由 GPT 生成】

问题是关于利用Qt5Agg绘制散点图的，其中文件1负责生成按钮，点击按钮后将数据框参数传递给文件2，文件2接收参数并绘制散点图并添加滚动条。问题是当通过文件1调用文件2时，程序会闪退。需要找出导致程序闪退的原因并解决。

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^

PyQt5_pyqtgraph散点图
可以参考下

PyQt5_pyqtgraph散点图_pyqtgraph 散点图_程序猿与金融与科技的博客-CSDN博客目录效果：代码：使用：效果：代码：需要的包与字符串横坐标控件import sys,jsonfrom typing import Dict,Anyfrom PyQt5 import QtCore,QtGui,QtWidgetsimport pyqtgraph as pgimport pyqtgraph.examplespg.setConfigOption('background','w')pg.setConfigOption('foreground','k')_pyqtgraph 散点图

https://blog.csdn.net/m0_37967652/article/details/124448158

pyqt5使用pyqtgraph绘制多个Y值散点图_pyqtgraph绘制2000个点_东木月的博客-CSDN博客 pyqt5使用pyqtgraph绘制多个Y值散点图_pyqtgraph绘制2000个点

https://blog.csdn.net/lm_is_dc/article/details/125977896

对于文件2，你可以使用以下代码来实例化并绘制散点图：

import sys
from PyQt5 import QtWidgets
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.figure import Figure


class ScatterPlot(QtWidgets.QMainWindow):
    def __init__(self, df):
        super().__init__()

        # 设置窗口标题
        self.setWindowTitle('Scatter Plot')

        # 创建一个matplotlib图像对象
        self.fig = Figure()

        # 将matplotlib图像对象转换成QtWidget对象
        self.canvas = FigureCanvas(self.fig)

        # 设置图像背景为白色
        self.fig.patch.set_facecolor('#FFFFFF')

        # 创建一个布局对象
        layout = QtWidgets.QVBoxLayout()

        # 把图像添加到布局上
        layout.addWidget(self.canvas)

        # 创建一个中心窗口部件
        widget = QtWidgets.QWidget()

        # 把布局添加到中心窗口部件上
        widget.setLayout(layout)

        # 把中心窗口部件设置为主窗口部件
        self.setCentralWidget(widget)

        # 创建一个散点图对象，并添加到matplotlib图像中
        ax = self.fig.add_subplot(111)
        ax.scatter(df['x'], df['y'])

        # 设置散点图的标题、x轴和y轴标签
        ax.set_title('Scatter Plot')
        ax.set_xlabel('X')
        ax.set_ylabel('Y')

        # 调整散点图的布局
        self.fig.tight_layout()

        # 创建一个滚动条对象，并添加到窗口底部
        scroll = QtWidgets.QScrollBar(QtCore.Qt.Horizontal)
        self.statusBar().addPermanentWidget(scroll)

        # 把滚动条和图像部件绑定
        scroll.setMaximum(canvas.scroll_max)
        scroll.sliderMoved.connect(canvas.slider_moved)

        # 调整窗口大小
        self.resize(800, 600)

        # 显示窗口
        self.show()


if __name__ == '__main__':
    # 从命令行参数中获取数据框文件路径
    df_path = sys.argv[1]

    # 加载数据框文件
    df = pd.read_csv(df_path)

    # 创建应用程序对象
    app = QtWidgets.QApplication(sys.argv)

    # 创建散点图对象
    scatter_plot = ScatterPlot(df)

    # 运行应用程序
    sys.exit(app.exec_())

在上述代码中，我们创建了一个名为ScatterPlot的类，它继承自QtWidgets.QMainWindow类。在类的构造方法中，我们首先设置了窗口标题，并创建了一个空的matplotlib图像对象。然后，我们将matplotlib图像对象转换成QtWidget对象，并将其添加到一个垂直布局中。接下来，我们创建了一个散点图，并将其添加到matplotlib图像对象中。最后，我们创建了一个滚动条对象，将其添加到窗口底部，并将其与图像部件绑定。在最后一步中，我们展示了窗口。

在文件1中，当你点击按钮时，你需要向文件2传递一个df数据框参数。你可以使用以下代码调用文件2并传递参数：

import os
import subprocess

# 指定文件2的路径
file_2_path = '/path/to/file2.py'

# 加载数据框文件
df = pd.read_csv('/path/to/data.csv')

# 创建命令行参数
args = [sys.executable, file_2_path, df.to_json()]

# 调用文件2，并传递命令行参数
subprocess.call(args)

在上述代码中，我们首先指定了文件2的路径。然后，我们加载数据框文件，并将其转换成JSON格式，以便在命令行参数中传递。接下来，我们创建了一个命令行参数列表，其中第一个元素是Python解释器的路径，第二个元素是文件2的路径，第三个元素是df数据框的JSON表示。最后，我们使用subprocess.call()函数调用文件2，并传递命令行参数。

可能是由于在文件1中创建的Qt应用程序实例没有正确地传递到文件2中。在文件2中，你可能需要获取这个实例来进行绘图操作。因此，你不应该在文件2中创建新的application，而是接收文件1传来的实例即可。

可能是参数没有正确传递

python绘图之散点图_python画散点图_不见月光见星光的博客-CSDN博客 python中matplotlib库入门（2）之绘制散点图一.导入库import matplotlib.pyplot as plt二.设置文字plt.title("double number", fontsize=24)plt.xlabel("number", fontsize=14)plt.ylabel("double", fontsize=14)三.设置坐标轴参数plt.axis([0, 15, 0, 30])q前面两个数为x轴的始末，后面则为y四.绘制点plt.scatt_python画散点图

https://blog.csdn.net/weixin_50187215/article/details/113541848?ops_request_misc=&request_id=&biz_id=102&utm_term=pythong%E7%BB%98%E5%88%B6%E6%95%A3%E7%82%B9%E5%9B%BE%E7%9A%84%E9%97%AE%E9%A2%98&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-0-113541848.142^v92^controlT0_1&spm=1018.2226.3001.4187

将绘图方法放在__init__中

根据您提供的文件2代码，它实现了一个绘制散点图的类qt，并在创建类的实例时接受一个DataFrame参数，然后在一个带有滚动条的Qt窗口中绘制散点图。该类在单独运行时应该没有问题。

你的问题可能是由于在文件1中导入和使用了文件2中的qt类时引起的。在这种情况下，如果你在文件1中导入了文件2并实例化了qt类，那么文件2中的app.exec_()将会与文件1中的事件循环冲突，可能导致程序崩溃或冻结。

为了解决这个问题，您可以将文件2中的app.exec_()部分注释掉，并确保在文件1中正确实例化和调用qt类。这样，您可以避免事件循环冲突。

修改后文件2代码如下：


import sys
import matplotlib
import matplotlib.pyplot as plt
matplotlib.use('Qt5Agg')
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from PyQt5.QtWidgets import QApplication, QMainWindow, QScrollArea, QWidget, QVBoxLayout
import pandas as pd

class qt(QMainWindow):
    def __init__(self, df):
        print(df)
        app = QApplication([])
        window = QMainWindow()
        scroll_area = QScrollArea()
        widget = QWidget()
        layout = QVBoxLayout(widget)

        fig, ax = plt.subplots(figsize=(40, 10))

        x = df['x'].tolist()
        y = df['y'].tolist()
        print(x, y)

        ax.scatter(x, y)

        layout.addWidget(FigureCanvas(fig))

        scroll_area.setWidget(widget)
        window.setCentralWidget(scroll_area)

        window.show()  # 注释掉 app.exec_() 这一行

# if __name__ == "__main__":
#     x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#     y = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
#     df = pd.DataFrame({"x": x, "y": y})
#     app = QApplication(sys.argv)
#     window = qt(df)
#     window.show()
#     sys.exit(app.exec_())

问题点: 代码编写错误,导致文件1调用文件2失败.核心问题在于调用文件2的方式.
代码修改多处(2个代码文件都修改了),请采纳,谢谢
代码修改如下:
文件1

import sys

import pandas as pd
from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton

import 文件2


class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Main Window")
        self.setGeometry(100, 100, 500, 500)

        button = QPushButton("传参绘图", self)
        button.setGeometry(200, 200, 120, 40)
        button.clicked.connect(self.create_scatter_plot)

    def create_scatter_plot(self):
        # 有一个数据框df
        x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        y = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
        df = pd.DataFrame({"x": x, "y": y})
        # 将数据框参数传递给另一个文件
        # 一定要 self.
        self.A = 文件2.plot_qt(df)
        self.A.show()


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())

文件2

import sys

import matplotlib
import matplotlib.pyplot as plt

matplotlib.use('Qt5Agg')  # 设置后端为Qt5
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas  # 导入Qt5Agg的FigureCanvas
from PyQt5.QtWidgets import QApplication, QScrollArea, QWidget, QVBoxLayout  # 导入滚动区域的Qt窗口控件
import pandas as pd


class plot_qt(QWidget):
    def __init__(self, df):
        super().__init__()
        print(df)
        scroll_area = QScrollArea()
        widget = QWidget()
        layout = QVBoxLayout(widget)
        # 创建Matplotlib图像
        fig, ax = plt.subplots(figsize=(40, 10))
        # 生成测试数据
        x = df['x'].tolist()
        y = df['y'].tolist()
        print(x, y)
        # 绘制散点图
        ax.scatter(x, y)
        # 将Matplotlib图像添加到布局中
        layout.addWidget(FigureCanvas(fig))
        # 设置滚动区域的布局
        scroll_area.setWidget(widget)
        self.setLayout(layout)


if __name__ == "__main__":
    x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    y = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
    df = pd.DataFrame({"x": x, "y": y})
    app = QApplication(sys.argv)
    A = plot_qt(df)
    A.show()
    sys.exit(app.exec_())

根据您提供的代码，我注意到您在文件2中实例化了一个QApplication对象。然而，在文件1中已经实例化了一个QApplication对象。这可能导致冲突和闪退。

为了解决这个问题，您可以将文件2中的QApplication实例化移动到if __name__ == "__main__":条件下，以确保只有在文件2作为主程序运行时才会实例化QApplication对象。

请尝试将文件2的代码修改如下：

import sys
import matplotlib
import matplotlib.pyplot as plt
matplotlib.use('Qt5Agg')    # 设置后端为Qt5
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas    # 导入Qt5Agg的FigureCanvas
from PyQt5.QtWidgets import QApplication, QMainWindow, QScrollArea, QWidget, QVBoxLayout # 导入滚动区域的Qt窗口控件
import pandas as pd

class qt(QMainWindow):
    def __init__(self, df):
        print(df)
        # 创建滚动区域的Qt窗口
        window = QMainWindow()
        scroll_area = QScrollArea()
        widget = QWidget()
        layout = QVBoxLayout(widget)

        # 创建Matplotlib图像
        fig, ax = plt.subplots(figsize=(40, 10))

        # 生成测试数据
        x = df['x'].tolist()
        y = df['y'].tolist()
        print(x,y)

        # 绘制散点图
        ax.scatter(x, y)

        # 将Matplotlib图像添加到布局中
        layout.addWidget(FigureCanvas(fig))

        # 设置滚动区域的布局
        scroll_area.setWidget(widget)
        window.setCentralWidget(scroll_area)

        # 显示窗口
        window.show()

if __name__ == "__main__":
    x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    y = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
    df = pd.DataFrame({"x": x, "y": y})
    app = QApplication(sys.argv)
    window = qt(df)
    window.show()
    sys.exit(app.exec_())

请尝试运行修改后的代码，看看问题是否解决了。

在Python中，我们可以使用Matplotlib库来进行数据可视化，而Matplotlib库中的一个模块就是pyplot，可以快速绘制一些简单的图形，如折线图、散点图等。在Matplotlib中，还有一种绘制图形的方式是利用FigureCanvas，它可以更加灵活地绘制图形，并且可以将绘制好的图形嵌入到GUI界面中。而在GUI开发中，Qt是一个非常流行的工具包，结合Matplotlib和Qt可以实现更加丰富的数据可视化。

在利用Qt5Agg绘制散点图时，一般可以通过传参的方式将数据传递给另一个文件进行处理和绘图。具体实现的步骤如下：

创建界面窗口

首先，我们需要创建一个界面窗口，可以使用Qt Designer来设计窗口的布局，在代码中使用PyQt5对窗口进行初始化和设置，设置窗口中需要添加的控件、布局方式等。

创建FigureCanvas

在窗口中添加一个绘图控件Qwidget，将其作为绘制图形的容器，然后创建FigureCanvas，将其添加到Qwidget中。FigureCanvas可以理解为绘图板，所有的绘图操作都在FigureCanvas上进行，FigureCanvas是Matplotlib中的一个类。

绘制散点图

在另一个文件中对数据进行处理和绘制散点图，在这个文件中需要导入Matplotlib库和numpy库，使用Matplotlib库来绘制图形，numpy库用于数组的处理。在绘制散点图时，需要设置散点图的横轴、纵轴和点的大小、颜色等属性，将绘制好的散点图传递给主窗口界面进行显示。

传参

在主窗口中，需要设置一个按钮或其他的触发器来触发散点图的绘制操作，在按钮被点击时，将需要绘制的散点图数据传递给另一个文件进行处理和绘图。传参可以使用类似于Python函数参数的方式，在按钮的点击事件中设置需要传递的参数，然后在另一个文件的函数中接收参数进行处理。

总结

在利用Qt5Agg进行散点图绘制时，需要注意的是界面和绘图是分开的两个部分，需要使用FigureCanvas将绘图板添加到界面上，同时在不同的文件中进行不同的操作，通过传参的方式进行数据的传递和处理。在编写代码时需要注意代码的规范性、可读性和可维护性，同时需要严格遵守Matplotlib和Qt5的API规范，避免出现意外的错误。