Skip to main content
Engineering LibreTexts

6.9: String Methods

  • Page ID
  • \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    \( \newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\)

    ( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\id}{\mathrm{id}}\)

    \( \newcommand{\Span}{\mathrm{span}}\)

    \( \newcommand{\kernel}{\mathrm{null}\,}\)

    \( \newcommand{\range}{\mathrm{range}\,}\)

    \( \newcommand{\RealPart}{\mathrm{Re}}\)

    \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)

    \( \newcommand{\Argument}{\mathrm{Arg}}\)

    \( \newcommand{\norm}[1]{\| #1 \|}\)

    \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)

    \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\AA}{\unicode[.8,0]{x212B}}\)

    \( \newcommand{\vectorA}[1]{\vec{#1}}      % arrow\)

    \( \newcommand{\vectorAt}[1]{\vec{\text{#1}}}      % arrow\)

    \( \newcommand{\vectorB}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vectorC}[1]{\textbf{#1}} \)

    \( \newcommand{\vectorD}[1]{\overrightarrow{#1}} \)

    \( \newcommand{\vectorDt}[1]{\overrightarrow{\text{#1}}} \)

    \( \newcommand{\vectE}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash{\mathbf {#1}}}} \)

    \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)

    \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)

    Strings are an example of Python objects. An object contains both data (the actual string itself) and methods, which are effectively functions that are built into the object and are available to any instance of the object.

    Python has a function called dir which lists the methods available for an object. The type function shows the type of an object and the dir function shows the available methods.

    >>> stuff = 'Hello world'
    >>> type(stuff)
    <class 'str'>
    >>> dir(stuff)
    ['capitalize', 'casefold', 'center', 'count', 'encode',
    'endswith', 'expandtabs', 'find', 'format', 'format_map',
    'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit',
    'isidentifier', 'islower', 'isnumeric', 'isprintable',
    'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower',
    'lstrip', 'maketrans', 'partition', 'replace', 'rfind',
    'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip',
    'split', 'splitlines', 'startswith', 'strip', 'swapcase',
    'title', 'translate', 'upper', 'zfill']
    >>> help(str.capitalize)
    Help on method_descriptor:
        S.capitalize() -> str
        Return a capitalized version of S, i.e. make the first character
        have upper case and the rest lower case.

    While the dir function lists the methods, and you can use help to get some simple documentation on a method, a better source of documentation for string methods would be

    Calling a method is similar to calling a function (it takes arguments and returns a value) but the syntax is different. We call a method by appending the method name to the variable name using the period as a delimiter.

    For example, the method upper takes a string and returns a new string with all uppercase letters:

    Instead of the function syntax upper(word), it uses the method syntax word.upper().

    >>> word = 'banana'
    >>> new_word = word.upper()
    >>> print(new_word)

    This form of dot notation specifies the name of the method, upper, and the name of the string to apply the method to, word. The empty parentheses indicate that this method takes no argument.

    A method call is called an invocation; in this case, we would say that we are invoking upper on the word.

    For example, there is a string method named find that searches for the position of one string within another:

    >>> word = 'banana'
    >>> index = word.find('a')
    >>> print(index)

    In this example, we invoke find on word and pass the letter we are looking for as a parameter.

    The find method can find substrings as well as characters:

    >>> word.find('na')

    It can take as a second argument the index where it should start:

    >>> word.find('na', 3)

    One common task is to remove white space (spaces, tabs, or newlines) from the beginning and end of a string using the strip method:

    >>> line = '  Here we go  '
    >>> line.strip()
    'Here we go'

    Some methods such as startswith return boolean values.

    >>> line = 'Have a nice day'
    >>> line.startswith('Have')
    >>> line.startswith('h')

    You will note that startswith requires case to match, so sometimes we take a line and map it all to lowercase before we do any checking using the lower method.

    >>> line = 'Have a nice day'
    >>> line.startswith('h')
    >>> line.lower()
    'have a nice day'
    >>> line.lower().startswith('h')

    In the last example, the method lower is called and then we use startswith to see if the resulting lowercase string starts with the letter "h". As long as we are careful with the order, we can make multiple method calls in a single expression.

    Exercise 4:

    There is a string method called count that is similar to the function in the previous exercise. Read the documentation of this method at and write an invocation that counts the number of times the letter a occurs in "banana".

    This page titled 6.9: String Methods is shared under a CC BY-NC-SA 4.0 license and was authored, remixed, and/or curated by Chuck Severance via source content that was edited to the style and standards of the LibreTexts platform; a detailed edit history is available upon request.

    • Was this article helpful?