Python跨脚本共享嵌套函数内变量：音频播放Flag同步方案咨询

Hey there! Let's break down how to solve your problem with sharing that Flag variable—both inside nested functions and across different scripts. I'll walk you through practical, easy-to-follow examples since you're new to Python.

First, let's split your problem into two parts: accessing Flag inside nested functions, and sharing it across separate scripts. Let's tackle each with code snippets you can adapt.

1. Accessing Flag in Nested Functions (Same Script) #

If your Flag is defined in an outer function and used in a nested one, the global keyword won't work here—since global refers to top-level variables, not those in enclosing function scopes. Here are two straightforward fixes:

Option 1: Use the nonlocal Keyword #

This tells Python you want to modify a variable from the nearest enclosing scope (not the global one):

# -*- coding: utf-8 -*-
import sched, time, random  # Include your pi-related modules here

def audio_controller():
    flag = 0  # Our target Flag variable
    
    def play_audio():
        nonlocal flag
        flag = 1
        print("Audio playing — Flag set to 1")
        # Insert your actual audio playback code here
        time.sleep(2)  # Simulate playback duration
        # When playback stops:
        flag = 0
        print("Audio stopped — Flag set to 0")
    
    def get_current_flag():
        nonlocal flag
        return flag
    
    # Expose nested functions and flag access
    return play_audio, get_current_flag

# Usage example
start_playback, check_flag = audio_controller()
start_playback()
print(f"Current Flag value: {check_flag()}")  # Should output 0 after playback

Option 2: Use a Mutable Container (Dict/List) #

Mutable objects like dictionaries or lists don't require keyword declarations because you're modifying their contents, not reassigning the variable itself. This is great if you want to avoid extra keywords:

def audio_controller():
    flag_state = {"value": 0}  # Mutable dict to hold Flag
    
    def play_audio():
        flag_state["value"] = 1
        print("Playing... Flag = 1")
        # Your audio code here
        time.sleep(3)  # Simulate playback
        flag_state["value"] = 0
        print("Stopped... Flag = 0")
    
    return play_audio, lambda: flag_state["value"]

# Usage
play, get_flag = audio_controller()
play()
print(get_flag())  # Outputs 0

2. Sharing Flag Across Different Scripts #

If you need Flag accessible between separate Python files (running either in the same process or as standalone processes), here are reliable approaches:

Option 1: Module-Level Variable (Same Process) #

Define Flag in a shared module that both scripts import. Let's create a shared_state.py file:

# shared_state.py
audio_flag = 0  # Global variable accessible to any script importing this module

Then in your audio playback script (audio_player.py):

# audio_player.py
import shared_state
import time

def play_audio():
    shared_state.audio_flag = 1
    print("Audio started")
    time.sleep(3)  # Simulate playback
    shared_state.audio_flag = 0
    print("Audio ended")

And in your CSV writer script (csv_logger.py):

# csv_logger.py
import shared_state
import csv
import time
import threading

def write_flag_to_csv():
    with open("flag_log.csv", "a", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(["Timestamp", "Flag Value"])  # Header
        while True:
            timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
            writer.writerow([timestamp, shared_state.audio_flag])
            time.sleep(1)  # Log every second

# Run both tasks in parallel using threads
if __name__ == "__main__":
    audio_thread = threading.Thread(target=audio_player.play_audio)
    log_thread = threading.Thread(target=write_flag_to_csv)
    
    audio_thread.start()
    log_thread.start()
    
    audio_thread.join()
    log_thread.join()

Option 2: Direct CSV Updates (Separate Processes) #

If your scripts run as standalone processes (not imported into each other), update the CSV file directly whenever Flag changes. Modify your audio script:

# audio_player.py
import csv
import time

def log_flag(flag_value):
    with open("flag_log.csv", "a", newline="") as f:
        writer = csv.writer(f)
        writer.writerow([time.strftime("%Y-%m-%d %H:%M:%S"), flag_value])

def play_audio():
    log_flag(1)
    print("Playing audio...")
    time.sleep(3)
    log_flag(0)
    print("Audio stopped.")

play_audio()

Your other script can then read the latest row from the CSV to get the current Flag value.

Option 3: Shared Memory (Fast Inter-Process Communication) #

For faster communication between separate processes, use multiprocessing.Value to create a shared integer:

# audio_player.py
from multiprocessing import Value
import time

def play_audio(shared_flag):
    shared_flag.value = 1
    print("Playing...")
    time.sleep(3)
    shared_flag.value = 0
    print("Stopped.")

if __name__ == "__main__":
    flag = Value('i', 0)  # 'i' denotes integer type
    play_audio(flag)

In your CSV logger process:

# csv_logger.py
from multiprocessing import Value, Process
import csv
import time

def write_flag(shared_flag):
    with open("flag_log.csv", "a", newline="") as f:
        writer = csv.writer(f)
        while True:
            writer.writerow([time.strftime("%Y-%m-%d %H:%M:%S"), shared_flag.value])
            time.sleep(1)

if __name__ == "__main__":
    flag = Value('i', 0)
    audio_process = Process(target=play_audio, args=(flag,))
    audio_process.start()
    write_flag(flag)
    audio_process.join()

Quick Tips #

• For nested functions: nonlocal is cleaner for scalar variables (like integers), while mutable containers avoid keyword clutter.
• For cross-script sharing: use module variables if scripts run in the same process; use CSV or shared memory if they're separate processes.
• If multiple threads/processes access Flag at the same time, add a lock (e.g., threading.Lock() or multiprocessing.Lock()) to prevent race conditions.

内容的提问来源于stack exchange，提问作者Diana Laura