Of course! In Python, "插入" a character into a string is a very common task. Since strings in Python are immutable (meaning they cannot be changed after creation), you can't directly insert a character into an existing string.

The standard approach is to convert the string to a list of characters, perform the insertion, and then join the list back into a string.

Here’s a complete guide on how to do this, from the most common method to more advanced ones.

Method 1: The Classic list() Conversion Method (Most Common)

This is the most straightforward and widely understood method. It's perfect for learning and general use.

Step-by-Step Explanation:

1. Convert the string to a list: Use the list() constructor. This breaks the string into a list where each character is an element.

   my_string = "hello"
   char_list = list(my_string)
   # char_list is now ['h', 'e', 'l', 'l', 'o']

2. Insert the character: Use the list.insert(index, element) method. This method modifies the list in-place.
   • index: The position where you want to insert the new character. Important: The index is 0-based.
   • element: The character you want to insert.

     # Insert 'X' at index 2 (between 'e' and 'l')
     char_list.insert(2, 'X')
     # char_list is now ['h', 'e', 'X', 'l', 'l', 'o']

3. Join the list back into a string: Use the str.join() method to combine the list elements into a new string.

   new_string = "".join(char_list)
   # new_string is now "heXllo"

Complete Code Example:

def insert_char(original_string, char_to_insert, position):
    """
    Inserts a character into a string at a specific position.
    Args:
        original_string (str): The original string.
        char_to_insert (str): The character to insert.
        position (int): The 0-based index to insert at.
    Returns:
        str: The new string with the character inserted.
    """
    # 1. Convert string to a list of characters
    char_list = list(original_string)
    # 2. Insert the new character at the specified position
    char_list.insert(position, char_to_insert)
    # 3. Join the list back into a string
    new_string = "".join(char_list)
    return new_string
# --- Examples ---
my_string = "python"
new_char = '3'
insert_pos = 2  # Insert between 't' and 'h'
result = insert_char(my_string, new_char, insert_pos)
print(f"Original: '{my_string}'")
print(f"Result:   '{result}'")  # Output: 'py3thon'
# Example: Inserting at the beginning
result_beginning = insert_char("world", "a", 0)
print(f"Insert at beginning: '{result_beginning}'") # Output: 'aworld'
# Example: Inserting at the end
result_end = insert_char("list", "!", 4)
print(f"Insert at end: '{result_end}'") # Output: 'list!'

Method 2: String Slicing (More Pythonic and Efficient)

This method is often preferred by experienced Python developers because it's more concise and can be slightly faster as it avoids creating an intermediate list.

The logic is to split the original string into two parts and concatenate them with the new character in the middle.

Formula:

new_string = original_string[:position] + char_to_insert + original_string[position:]

How it Works:

• original_string[:position]: Gets the part of the string from the beginning up to (but not including) the position.
• char_to_insert: The character you want to add.
• original_string[position:]: Gets the part of the string from the position to the end.

Complete Code Example:

def insert_char_slice(original_string, char_to_insert, position):
    """
    Inserts a character into a string using slicing.
    Args:
        original_string (str): The original string.
        char_to_insert (str): The character to insert.
        position (int): The 0-based index to insert at.
    Returns:
        str: The new string with the character inserted.
    """
    return original_string[:position] + char_to_insert + original_string[position:]
# --- Examples ---
my_string = "python"
new_char = '3'
insert_pos = 2
result = insert_char_slice(my_string, new_char, insert_pos)
print(f"Original: '{my_string}'")
print(f"Result:   '{result}'")  # Output: 'py3thon'
# Example: Inserting at the beginning
result_beginning = insert_char_slice("world", "a", 0)
print(f"Insert at beginning: '{result_beginning}'") # Output: 'aworld'
# Example: Inserting at the end
result_end = insert_char_slice("list", "!", 4)
print(f"Insert at end: '{result_end}'") # Output: 'list!'

Comparison of Methods

Important Considerations

1. Indexing: Remember that Python uses 0-based indexing. The first character is at index 0.

2. Inserting at the End: To insert a character at the very end, the position should be len(original_string). Both methods handle this correctly.

   
   （图片来源网络，侵删）

3. Inserting Multiple Characters: If you want to insert a substring (not just a single character), the slicing method is even more convenient.

   original = "I like apples"
   to_insert = "green "
   position = 7
   new_string = original[:position] + to_insert + original[position:]
   print(new_string)
   # Output: 'I like green apples'