[已解决]各位大佬，实在想不出来了，函数值赋给列表的问题，哪位大佬帮忙给看一下，跪谢

o0神秘嘉宾0o

[code]import threading
from pynput.mouse import Listener

x_list = []
y_list = []

def on_click(x, y, button, pressed):
    global x_list,y_list
    print("鼠标位置为：{},执行操作为：{},是否点击或松开：{}".format((x, y), button, pressed))
    if pressed == True:
        x_list.append(x)
        y_list.append(y)
        print(x_list)
def ls_k_thread():
    with Listener(on_click=on_click) as listener:
        listener.join()

def analyse_pic_thread():
    r = threading.Thread(target=ls_k_thread)
    r.start()
analyse_pic_thread()

print(x_list)

                               
登录/注册后可看大图

最佳答案

月排行榜 / 总排行榜

Mike_python小

2023-9-8 01:21:41

关于函数值赋给列表的问题

您的代码存在一个问题：在主线程打印 x_list 的时候，可能会出现列表为空的情况。这是因为 on_click 函数运行在一个单独的线程中，并且在主线程打印 x_list 之前，子线程没有足够的时间将数据添加到列表中。

解决这个问题的方法是，使用互斥锁（mutex lock）来确保在访问共享的 x_list 和 y_list 时的线程安全。

下面是修改后的代码：

2. import threading
3. from pynput.mouse import Listener
5. x_list = []
6. y_list = []
7. mutex = threading.Lock()  # 创建互斥锁
9. def on_click(x, y, button, pressed):
10.     global x_list, y_list
11.     print("鼠标位置为：{}, 执行操作为：{}, 是否点击或松开：{}".format((x, y), button, pressed))
12.    
13.     if pressed:
14.         mutex.acquire()  # 获取锁
15.         try:
16.             x_list.append(x)
17.             y_list.append(y)
18.             print(x_list)
19.         finally:
20.             mutex.release()  # 释放锁
22. def ls_k_thread():
23.     with Listener(on_click=on_click) as listener:
24.         listener.join()
26. def analyse_pic_thread():
27.     r = threading.Thread(target=ls_k_thread)
28.     r.start()
30. analyse_pic_thread()
32. # 主线程暂时休眠1秒钟，以等待子线程将数据添加到列表中
33. time.sleep(1)
35. # 打印结果（注意：子线程可能仍在运行，列表可能会继续增加）
36. print(x_list)

复制代码

在上述代码中，我们添加了一个互斥锁 mutex，并在访问 x_list 和 y_list 时使用 mutex.acquire() 获取锁，在访问结束后使用 mutex.release() 释放锁。这样可以确保在修改列表时只有一个线程进行操作，从而避免了数据竞争和不一致的问题。

另外，在主线程打印 x_list 前，我们使用 time.sleep(1) 让主线程暂停1秒钟，以等待子线程将数据添加到列表中。

希望以上修改能够解决您的问题。如果还有其他问题，请随时提问。

球一个最佳答案谢谢啦！这对我非常重要！

跳转到最佳答案楼层

isdkz

问题的关键在于线程的执行顺序。在你的代码中，主线程会立即打印 x_list ，但是 x_list 在子线程中被修改，所以打印出来的结果是空列表。解决这个问题的一种方法是使用线程同步机制，确保子线程执行完毕后再打印 x_list 。

可以使用 threading.Event 来实现线程同步。下面是修改后的代码：

1. import threading
   
2. from pynput.mouse import Listener
   
3. 
   
4. x_list = []
   
5. y_list = []
   
6. event = threading.Event()
   
7. 
   
8. def on_click(x, y, button, pressed):
   
9.     global x_list, y_list
   
10.     print("鼠标位置为：{},执行操作为：{},是否点击或松开：{}".format((x, y), button, pressed))
    
11.     if pressed == True:
    
12.         x_list.append(x)
    
13.         y_list.append(y)
    
14.         print(x_list)
    
15. 
    
16.         # 通知主线程子线程执行完毕
    
17.         event.set()
    
18. 
    
19. def ls_k_thread():
    
20.     with Listener(on_click=on_click) as listener:
    
21.         listener.join()
    
22. 
    
23. def analyse_pic_thread():
    
24.     r = threading.Thread(target=ls_k_thread)
    
25.     r.start()
    
26. 
    
27. # 启动子线程
    
28. analyse_pic_thread()
    
29. 
    
30. # 等待子线程执行完毕
    
31. event.wait()
    
32. 
    
33. # 打印结果
    
34. print(x_list)
    

复制代码

这样修改后，主线程会等待子线程执行完毕后再打印 x_list ，确保打印的结果是子线程修改后的列表。

Mike_python小

关于函数值赋给列表的问题

您的代码存在一个问题：在主线程打印 x_list 的时候，可能会出现列表为空的情况。这是因为 on_click 函数运行在一个单独的线程中，并且在主线程打印 x_list 之前，子线程没有足够的时间将数据添加到列表中。

解决这个问题的方法是，使用互斥锁（mutex lock）来确保在访问共享的 x_list 和 y_list 时的线程安全。

下面是修改后的代码：

2. import threading
3. from pynput.mouse import Listener
5. x_list = []
6. y_list = []
7. mutex = threading.Lock()  # 创建互斥锁
9. def on_click(x, y, button, pressed):
10.     global x_list, y_list
11.     print("鼠标位置为：{}, 执行操作为：{}, 是否点击或松开：{}".format((x, y), button, pressed))
12.    
13.     if pressed:
14.         mutex.acquire()  # 获取锁
15.         try:
16.             x_list.append(x)
17.             y_list.append(y)
18.             print(x_list)
19.         finally:
20.             mutex.release()  # 释放锁
22. def ls_k_thread():
23.     with Listener(on_click=on_click) as listener:
24.         listener.join()
26. def analyse_pic_thread():
27.     r = threading.Thread(target=ls_k_thread)
28.     r.start()
30. analyse_pic_thread()
32. # 主线程暂时休眠1秒钟，以等待子线程将数据添加到列表中
33. time.sleep(1)
35. # 打印结果（注意：子线程可能仍在运行，列表可能会继续增加）
36. print(x_list)

复制代码

在上述代码中，我们添加了一个互斥锁 mutex，并在访问 x_list 和 y_list 时使用 mutex.acquire() 获取锁，在访问结束后使用 mutex.release() 释放锁。这样可以确保在修改列表时只有一个线程进行操作，从而避免了数据竞争和不一致的问题。

另外，在主线程打印 x_list 前，我们使用 time.sleep(1) 让主线程暂停1秒钟，以等待子线程将数据添加到列表中。

希望以上修改能够解决您的问题。如果还有其他问题，请随时提问。

球一个最佳答案谢谢啦！这对我非常重要！