Python String Functions: Methods, Examples, and Uses

Formulas & functions · Updated November 22, 2026

Python string functions are mainly string methods—operations such as upper(), strip(), replace(), and split() that work on text. W3Schools’ Python string reference introduces these methods, and the key idea to know first is that they return a result rather than changing the original string.

What W3Schools means by Python string functions

When people search for “string functions in Python W3Schools,” they are usually looking for W3Schools’ tutorial or reference list of ways to process text. In Python, many everyday string operations are technically methods: they are called after a string and a dot, as in name.upper(). Other useful operations are built-in functions, such as len(name), or operators, such as name in sentence. These categories are related, but they are not interchangeable terms.

A string is text enclosed in quotes, for example 'hello' or "hello". Python provides a large set of methods for changing letter case, trimming whitespace, searching, splitting, testing, and formatting strings. W3Schools is a convenient learning reference, especially for short examples. For details about behavior, version support, and edge cases, Python’s official documentation is the more complete reference.

It helps to learn methods in context rather than memorize a long list. First decide what needs to happen to the text—clean it, inspect it, divide it, or present it—and then choose a method whose behavior matches that job.

How Python strings and methods work

Python strings are immutable. A method such as upper() does not alter the existing string in place; it returns a new string. For example, with word = 'python', evaluating word.upper() produces 'PYTHON', while word still contains 'python'. To keep the transformed value, assign it: word = word.upper(). This is a common source of confusion for new programmers.

Methods are called with parentheses, even when they need no extra information. Some accept arguments that specify what to search for or how to transform the text. Python is case-sensitive, so 'Name'.lower() and 'Name'.upper() are different method calls, and a string such as 'Python' is not equal to 'python' unless you normalize the case or otherwise compare them appropriately.

Here is a short example:

  • message = ' Hello, Python! ' stores a string with spaces at both ends.
  • clean = message.strip() returns a version without those outer spaces.
  • clean = clean.replace('Python', 'world') returns 'Hello, world!'.

Each expression produces a value. Assignment is what stores that value under a name.

Methods for changing letter case

Case methods are useful for display and for preparing text for comparisons. upper() converts letters to uppercase; lower() converts them to lowercase. capitalize() uppercases the first character and lowercases the remaining characters, while title() applies title-style capitalization to words. Title casing is a simple text transformation, not a reliable way to format every personal name, heading, or language correctly.

For case-insensitive comparisons involving Unicode text, casefold() is often a better choice than lower(). It is designed for caseless matching and may transform some characters more extensively. A simple comparison can look like this: 'Python'.casefold() == 'PYTHON'.casefold(), which evaluates to True. Case folding is not the same as removing accents or making arbitrary text linguistically identical.

For example, if input should be accepted regardless of capitalization, a program can compare normalized values:

  • answer = 'YES'
  • if answer.casefold() == 'yes': checks for the same word without treating letter case as significant.

Normalization is useful for predictable comparisons, but keep the original text when capitalization matters for display or record keeping.

Cleaning and replacing text

strip() removes whitespace from both ends of a string. lstrip() removes it from the left, and rstrip() removes it from the right. These methods do not remove spaces from the middle. Thus, ' red blue '.strip() returns 'red blue', preserving the space between the words. They recognize whitespace such as spaces and line breaks, which makes them useful for cleaning input read from a prompt or file.

An optional argument to strip(chars) is a set of characters to remove from the ends, not a complete substring to remove. For example, 'xyHello yx'.strip('xy') removes any run of x or y characters at either end. It does not remove the exact sequence 'xy' as a unit. For exact prefix and suffix removal, Python 3.9 and later provide removeprefix() and removesuffix().

replace(old, new) returns a string with occurrences of old replaced by new. An optional third argument limits the number of replacements. For example, 'one-one'.replace('one', 'two', 1) returns 'two-one'. It is a literal text replacement, not a regular-expression operation; use Python’s re module when a pattern, rather than an exact substring, is required.

Splitting strings and joining them back together

split() divides a string into a list of strings. With no separator, it splits on runs of whitespace and does not include empty items caused by leading or trailing whitespace. For instance, 'red blue green'.split() returns ['red', 'blue', 'green']. With a specified separator, it splits at that exact string: 'red,blue,green'.split(',') returns three items. A maxsplit argument can limit how many splits occur.

The inverse pattern is join(), which combines an iterable of strings with the string used as the separator. The separator goes before the method call: ', '.join(['red', 'blue', 'green']) returns 'red, blue, green'. Every item supplied to join() must be a string. If a list contains numbers, convert them explicitly, for example with str(number), before joining.

One practical use is turning lines of input into cleaned values:

  • Start with raw = ' apple, pear, plum '.
  • Use raw.strip().split(',') to get a list of pieces.
  • Strip each piece as well, because splitting on a comma leaves the spaces next to commas intact; a list comprehension such as [item.strip() for item in raw.strip().split(',')] produces clean fruit names.

For structured data such as quoted CSV fields, a plain split on commas may be inadequate. Python’s csv module handles CSV conventions more safely.

Searching, checking, and counting

find(substring) returns the position of the first match, or -1 if the substring is absent. index(substring) also returns a position, but raises ValueError when there is no match. Choose find() when absence is an ordinary possibility you want to test; choose index() when a missing match should be treated as an error. Both can accept optional start and end positions.

For a simple yes-or-no question, in is often clearer: 'cat' in 'catalog' is True. The method count(substring) returns the number of non-overlapping occurrences. Prefix and suffix checks are available with startswith() and endswith(), which are generally preferable to manually slicing text just to test its beginning or ending.

String testing methods include isalpha(), isdigit(), isdecimal(), isalnum(), isspace(), islower(), and isupper(). They return Boolean values. Most of these tests return False for an empty string, and methods such as isalpha() require every character to meet the test—so 'hello!'.isalpha() is false because of the punctuation.

These checks do not validate a complete real-world format. For example, isdigit() does not establish that text is a valid integer in every intended input format, and an email address needs more than a simple alphabetic test. Use parsing or a purpose-built validation approach when the rules are more involved.

Formatting strings for readable output

Methods that alter text are different from tools that insert values into a message. For everyday output, f-strings are a clear option: name = 'Mina' followed by f'Hello, {name}!' produces 'Hello, Mina!'. F-strings were introduced in Python 3.6. Expressions can appear inside braces, and format specifications can control details such as decimal precision or alignment.

The format() method is another option, as in 'Hello, {}!'.format(name). It remains useful in existing code and when a format template is stored separately. Older percent-style formatting also exists, but new learners will usually find f-strings or format() easier to read. For example, an f-string can format a number to two digits after the decimal point with a format specification such as f'{price:.2f}'.

Do not confuse formatting with concatenation. Concatenating strings with + is fine for a small, fixed message, but f-strings make it easier to see where values go. If the values come from an untrusted source and are used to construct a database query or shell command, string formatting alone is not a security measure; use the relevant parameterized API instead.

Choosing the right method and avoiding mistakes

Start from the desired result, then choose the narrowest operation that expresses it. Use strip() for unwanted outer whitespace, replace() for literal substitutions, split() to make a list, join() to combine strings, and in or startswith() for straightforward checks. This makes code easier to understand than a chain of complex slices or manual loops.

  • If you need a transformed string, remember to use or assign the returned value.
  • If you need to check whether text exists, use in or handle the -1 result from find().
  • If exact delimiters matter, pass the intended separator to split(); its no-argument whitespace behavior is different.
  • If you are removing an exact prefix, use removeprefix() where available rather than assuming strip() removes a substring.
  • If text may contain non-ASCII characters, test with representative examples instead of assuming that every character rule is limited to English letters.

Another subtle point is that len(text) counts Unicode code points, not necessarily the visible characters a reader perceives. Some accented letters or emoji are represented by multiple code points, so the displayed character count can differ. For ordinary text processing this distinction rarely matters, but user-interface limits that count perceived characters may need Unicode-aware handling beyond basic string methods.

Frequently Asked Questions

What are the most commonly used Python string methods?
Common choices include lower(), upper(), strip(), replace(), split(), join(), find(), and startswith(). Which ones matter depends on whether you are cleaning, transforming, searching, or formatting text.

Are Python string methods functions?
They are callable operations, but technically a method is associated with an object and called with dot notation, such as text.lower(). A built-in function such as len(text) is called by its name and receives the string as an argument.

Does replace() change the original string?
No. Strings are immutable, so replace() returns a new string. Assign the result to a variable if you want to keep it, for example text = text.replace('old', 'new').

What is the difference between find() and index()?
Both return the position of a found substring. If it is absent, find() returns -1, while index() raises ValueError.

How do I remove spaces from a Python string?
Use strip() to remove whitespace from both ends, lstrip() for the left end, or rstrip() for the right end. To remove every ordinary space, including those inside the text, use a replacement such as text.replace(' ', ''), while remembering that tabs and line breaks are different characters.

Where can I find the full Python string method list?
W3Schools provides an accessible tutorial and method reference for learners. For a comprehensive and authoritative specification, consult the official Python documentation for the built-in string type, where method behavior and version details are documented.

Related

Try it: the Formula Explainer: paste any formula and see each function and reference in plain English.

More in Formulas & functions

Sources: Function behaviour and menu paths: Microsoft Support documentation for Excel. Method & sources

Spotted an error in this guide? Let us know.