Python Function for Interactive Communication

This document outlines a Python function designed to facilitate interactive conversational programming. The function can be trained to respond to specific prompts, allowing you to conduct experiments and refine its responses over time.

Main Features

• Interactive Communication: Allow the user to input prompts and receive responses.
• Training Mechanism: Enable the function to learn from new inputs.
• Robust Design: Input validation for handling unexpected cases.

Function Implementation

import random

class InteractiveResponder:
    def __init__(self):
        """Initializes the responder with default responses."""
        self.responses = {
            'hello': ['Hi there!', 'Hello!', 'Greetings!'],
            'how are you?': ['I\'m just a program, but thanks for asking!', 'Doing well, how can I assist you?'],
            'bye': ['Goodbye!', 'See you later!', 'Take care!']
        }

    def respond(self, user_input):
        """
        Responds to user input based on predefined keywords.

        Parameters:
        user_input (str): The input string from the user.

        Returns:
        str: A response string or a default message if input is not recognized.

        Raises:
        ValueError: If user_input is not a string.
        """
        if not isinstance(user_input, str):
            raise ValueError("Input must be a string.")
        
        # Normalize input to lowercase
        user_input = user_input.lower().strip()
        
        # Check for predefined responses
        if user_input in self.responses:
            return random.choice(self.responses[user_input])
        else:
            return "I'm sorry, I don't understand that yet. Please train me!"

    def train(self, user_input, response):
        """
        Trains the responder with a new user input and response.

        Parameters:
        user_input (str): The input string.
        response (str): The corresponding response string.

        Returns:
        None

        Raises:
        ValueError: If user_input or response is not a string.
        """
        if not isinstance(user_input, str) or not isinstance(response, str):
            raise ValueError("Both input and response must be strings.")
        
        user_input = user_input.lower().strip()
        
        # Add the new response to the dictionary
        if user_input not in self.responses:
            self.responses[user_input] = []
        
        self.responses[user_input].append(response)

Usage Example

The following example shows how to use the InteractiveResponder class for interaction and training:

# Create an instance of InteractiveResponder
responder = InteractiveResponder()

# Get a response for a known input
print(responder.respond("Hello"))  # Output can be one of the predefined greetings

# Trying an unknown input
print(responder.respond("What is your name?"))  # Default response

# Train the responder with new input and response
responder.train("What is your name?", "I am an interactive bot trained to help you.")

# Test the trained input
print(responder.respond("What is your name?"))  # Should respond with the newly trained response

Conclusion

This function allows interactive training of a responder in Python. It can be easily extended to include more functionalities. You may also explore courses on the Enterprise DNA Platform for more advanced data manipulation techniques and enhancements to your data science skills.

Feel free to run the provided code, experiment with training it, and observe how it evolves!