Could you please tell me what you liked or may have disliked about this code? What can be made better?#!/usr/bin/python3def change_char_at(ch, s, indx):        Strings in Python are immutable objects. So, it is not possible to change a    certain character in a string in place. For example, an attempt to run the    following code will fail with a TypeError:        s = spam        s[1] = z # TypeError: 'str' object does not support item assignment    What this function does is it provides you with a nice interface when you    want to change a character in a string at a certain index position. So, use    this function instead of doing everything manually which can sometimes be    tricky. Notice that the character parameter does not necessarily have to be    one character long. It can be an empty string which means that a character    at a certain position will effectively be deleted from the string. If it's    more than one character long, then they all will be inserted into the string    starting at the specified index position.    Parameters:    ch:   character to insert    s:    string to insert into    indx: index position where to insert the character        # Error handling    if type(ch) is not str:        raise TypeError(first argument must be a string)    if type(s) is not str or not len(s) > 0:        raise TypeError(second argument must be a non-empty string)    length = len(s) - 1    if not(indx >= 0 and indx <= length):        msg  = string index out of range;         msg += attempt to access index at {0}; .format(indx)        msg += allowable index range 0 to {0}.format(length)        raise IndexError(msg)    # Actual function logic    return s[:indx] + ch + s[indx + 1:]        Another possible implementation:        ls       = list(s)        ls[indx] = ch        return ''.join(ls)    This works well too and is equally good, but might be conspired unpythonic    by some compared to the one right above it.    def main():    my_string = spam    my_string = change_char_at(z, my_string, 1)    print(my_string) # prints szamif __name__ == __main__: main()
Changing a character in a string at a specified index position
python;strings
If this is intended to be a Python utility that can be imported with import, then you don't need the following shebang line:#!/usr/bin/python3You typically only use the above when you intend for a Python script to be executed as an executable. As far as I can tell, this script is intended to be a utility.In addition, if this script is intended to be an importable utility, then the following pieces of code should be placed in a separate tests.py file:def main():    my_string = spam    my_string = change_char_at(z, my_string, 1)    print(my_string) # prints szamif __name__ == __main__: main()When you want to perform type checking in Python, it's typically accepted that you don't use the type function. Rather, you should use the isinstance function, like this:if isinstance(something, sometype):    # Do somethingUnlike simply doing a comparison with the type function, isinstance will return true if the value you're checking inherits from the type you're checking the value against as well as simply returning true if the value and type match. If you don't want the additional behaviour of the isinstance function, then stick with type.But, type checking really isn't something you should be doing in Python anyways. If the user passes the wrong type, simply let the function throw an error. Don't bother trying to check the type. If you truly want to give your user an indication of what types should be passed, you can use function annotations, like this:def change_char_at(ch: str, s: str, indx: int):    pass