Python中函数处理外部对象的正确方法及AWS MQTT Broker回调函数使用疑问

Great questions! Let's break them down one by one, along with best practices for handling external variables in Python functions:

1. Why doesn't on_message_received need explicit arguments to be called? #

This is all about how callback functions work with the AWS MQTT SDK. When you pass on_message_received as the callback parameter to mqtt_connection.subscribe(), you're not calling the function right away—you're passing the function object itself to the SDK.

Think of it like telling the SDK: "When a message comes in on this topic, run this function for me." The SDK handles the rest: when it detects an incoming message, it will automatically invoke your callback function and pass the required arguments (topic, payload, and any additional keyword arguments) on your behalf. You don't need to manually pass these values because the SDK is responsible for triggering the function with the correct parameters.

2. How to pass an external variable to on_message_received and modify it? #

Your sample code hits a common Python scope trap: when you assign last_message = payload inside the function, Python treats this as creating a new local variable named last_message instead of modifying the global one you defined outside. Here are the correct approaches, ordered by use case:

Option 1: Use global (for global variables) #

If your variable lives in the global scope, declare it as global inside the callback to tell Python you want to modify the global variable, not create a local copy:

last_message = ''

def on_message_received(topic, payload, **kwargs):
    global last_message  # Explicitly reference the global variable
    print("Received message from topic '{}': {}".format(topic, payload))
    last_message = payload  # Now this updates the global variable

# Subscribe code remains unchanged

Option 2: Use nonlocal (for nested function scopes) #

If the variable is defined in an outer function (not global), use nonlocal to target the variable from the enclosing scope:

def main():
    last_message = ''

    def on_message_received(topic, payload, **kwargs):
        nonlocal last_message  # Reference the variable from the outer function
        print("Received message from topic '{}': {}".format(topic, payload))
        last_message = payload

    # Run subscribe code here...

Option 3: Use a mutable container (cleaner than global/nonlocal) #

Instead of using an immutable type like a string, use a mutable object (e.g., a dictionary or list). Since mutable objects can be modified in-place without reassigning the variable itself, you don't need special scope declarations:

msg_storage = {'last_message': ''}  # Mutable dictionary to hold state

def on_message_received(topic, payload, **kwargs):
    print("Received message from topic '{}': {}".format(topic, payload))
    msg_storage['last_message'] = payload  # Modify the dict's value directly

# Access the updated value with msg_storage['last_message']

Option 4: Use a class (best for complex applications) #

For larger projects, encapsulate your state and callback logic in a class. This keeps code organized and avoids scope issues entirely:

class MQTTMessageHandler:
    def __init__(self):
        self.last_message = ''

    def on_message_received(self, topic, payload, **kwargs):
        print("Received message from topic '{}': {}".format(topic, payload))
        self.last_message = payload  # Update the instance's attribute

# Usage:
handler = MQTTMessageHandler()
subscribe_future, packet_id = mqtt_connection.subscribe(
    topic=args.topic,
    qos=mqtt.QoS.AT_LEAST_ONCE,
    callback=handler.on_message_received  # Pass the class method as callback
)
subscribe_result = subscribe_future.result()

# Access the updated value with handler.last_message

General Python: Correct way to handle external objects in functions #

• Immutable objects (strings, integers, tuples): To modify the original variable outside the function, use global/nonlocal (for scope access) or return the new value and reassign it externally.
• Mutable objects (lists, dictionaries, class instances): You can modify their internal state (e.g., appending to a list, updating a dict key) without special declarations—since you're changing the data the variable points to, not reassigning the variable itself.

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