R.I.B.H.U. Academy^®

More String Methods

    In the previous page, you have learned about count(), index(), rindex() methods which not only tell about occurrence and position of sub-string, but also checks whether that sub-string is present in parent string or not. These three string methods also take second and third arguments for starting position (included) and ending position (excluded). These two positions are index number within which sub-string is to be searched.

print( 'Hello World'.count( 'a' ) )   # Outputs 0

print( 'Hello World'.index( 'a' ) )   # Outputs ValueError: substring not found

print( 'Hello World'.rindex( 'a' ) )   # Outputs ValueError: substring not found

    However, there are other string methods which can properly check whether any sub-string is present in parent string or not. I have specifically mentioned the output from help() function, when name of each of these methods or built-in functions, is provided as an argument within the parentheses. You should carefully peruse the return type, and return value of these methods or built-in functions, which you will use in programming scripts. See below of this page for details.

find(), rfind()

    The find() and rfind() methods checks whether any sub-string is present in the parent string or not, by searching (1) from left to right, and (2) from right to left, respectively. Each of these two methods also takes second and third arguments for starting position (included) and ending position (excluded). These two methods return -1 when the sub-string is not found, otherwise the index number of that sub-string.

print( help( str.find ) )

print( help( str.rfind ) )

print( 'Hello World'.find( 'r' ) )   # Outputs 8

print( 'Hello World'.find( 'a' ) )   # Outputs -1

print( 'Hello World'.find( 'l' ) )   # Outputs 2

print( 'Hello World'.find( 'l', 5, 10 ) )   # Outputs 9

print( 'Hello World'.rfind( 'r' ) )   # Outputs 8

print( 'Hello World'.rfind( 'a' ) )   # Outputs -1

print( 'Hello World'.rfind( 'l' ) )   # Outputs 9

print( 'Hello World'.rfind( 'l', 2, 5 ) )   # Outputs 3

    If you don't know the position of third argument, in all above string methods, you can also place -1 or -2, etc. (last index number, that is, negative indexing).

startswith(), endswith()

    The startswith() and endswith() methods are used to check whether any sub-string is present as prefix or suffix of the parent string. These two methods also take second and third arguments for starting position (included) and ending position (excluded).

print( help( str.startswith ) )

print( help( str.endswith ) )

print( 'Hello World'.startswith( 'h' ) )   # Outputs False

print( 'Hello World'.startswith( 'H' ) )   # Outputs True

print( 'Hello World'.startswith( 'He' ) )   # Outputs True

print( 'Hello World'.startswith( 'Wo', 6, 10 ) )   # Outputs True

print( 'Hello World'.endswith( 'd' ) )   # Outputs True

print( 'Hello World'.endswith( 'D' ) )   # Outputs False

print( 'Hello World'.endswith( 'ld' ) )   # Outputs True

print( 'Hello World'.endswith( 'o', 2, 5 ) )   # Outputs True

Return Type & Return Value

    Till now, you have see various built-in functions, and methods for some of these built-in functions. Some functions and methods may take many arguments, such as print() can take many arguments within the parentheses, separated by , (comma). Other functions and methods exactly take only one argument, such as input(), type(), len(), etc. Mostly, functions and methods take fixed number of arguments, as you can see in above examples, some of which are optional.

    You can see in above description that print() function has no returned value. Many parameters in any function, method or those in other modules, are of advanced uses. You can see in above description, that print() function has other parameters after value, ..., , which are unnecessary for beginners, and thus, overwhelm you.

print( help( print ) )   # Herein, print inside help() will display the same OUTPUT as shown above. The outer print() function executes the help( print ) statement.

print( help( type ) )   # first few lines of OUTPUT are shown herein below:

    Output of some functions cannot be used as returned value, such as print() and type(). But, other functions and methods generally, output specific data-type literals (return type), that is, len() returns integer data-type, input() returns string data-type. The output from the input() function must always be type-casted with int() or float() built-in function, before using in arithematic operations.

x = type( 'hello' )
print( x, type( x ) )   # Outputs <class 'str'> <class 'type'>

y = len( 'hello' )
print( y, type( y ) )   # Outputs 5 <class 'int'>

z = input( 'Write something: ' )
print( type( z ) )   # Outputs <class 'str'>

String Methods Return Types & Return Values

    You should be very careful while using any method of a specific built-in function, for example, str(). The str() function itself returns a string data-type, of the argument passed to it. In the following table, you can see that different methods or functions which can return same data-type, but the returned value will be different, depending on expressions (statements) passed as arguments inside the parentheses. For example, -1 is not index number, when find() or rfind() does not find the sub-string into the parent string.

my_var = str( 123 )
print( my_var, type( my_var ) )   # Outputs 123 <class 'str'>

    You should always remember what data-type is returned from a function or method, and also what value is received from such operation, expression, or statement. An integer value, for example, 9 can be index number in a parent string, and therefore it should not be treated/used for arithematic operations. You will learn about more functions and methods in later lessions, therefore, you should carefully handle OUTPUTs from them.