String | Haobin Tan

String

Sun, 01 May 2022 00:00:00 +0000

Source: Real Python

String = object that contains a sequence of character data.

Python provides a rich set of operators, functions, and methods for working with strings.

String Operators

The `+` Operator

The + operator concatenates strings. It returns a string consisting of the operands joined together

Example

>>> str_1 = "Hello"
>>> str_2 = "World"
>>> str_1 + str_2
HelloWorld

The `*` Operator

The * operator creates multiple copies of a string. If s is a string and n is an integer, either of the following expressions returns a string consisting of n concatenated copies of s:

s * n
n * s

If n <= 0, then the result is an empty string.

Example

>>> s = 'foo.'

>>> s * 4 # n > 0
'foo.foo.foo.foo.'
>>> 4 * s
'foo.foo.foo.foo.'

n <= 0:

>>> 'foo' * -8 # n <= 0
''

The `in` Operator

As string is essentially a list of characters, the membership operator in can also be used with string.

Example

>>> s = 'foo'

>>> s in 'That\'s food for thought.'
True
>>> s in 'That\'s good for now.'
False

>>> 'z' not in 'abc'
True
>>> 'z' not in 'xyz'
False

Build-in String Functions

Function	Description
`chr()`	Converts an integer to a character
`ord()`	Converts a character to an integer
`len()`	Returns the length of a string
`str()`	Returns a string representation of an object

`ord(c)`

Returns an integer value (ASCII or Unicode) for the given character.

Example

>>> ord('a')
97
>>> ord('#')
35

>>> ord('€')
8364
>>> ord('∑')
8721

`chr(n)`

chr() does the reverse of ord(). Given a numeric value n, chr(n) returns a string representing the character that corresponds to n.

Example

>>> chr(97)
'a'
>>> chr(35)
'#'

>>> chr(97)
'a'
>>> chr(35)
'#'

`len(s)`

Returns the length (number of characters) of a string.

Example

>>> s = 'I am a string.'
>>> len(s)
14

`str(obj)`

Returns a string representation of an object.

Example

>>> str(49.2)
'49.2'
>>> str(3+4j)
'(3+4j)'
>>> str(3 + 29)
'32'
>>> str('foo')
'foo'

List Operations for String

In Python, strings are ordered sequences of character data. Therefore, list operations (indexing, slicing, negative indexing) also work with string.

Interpolating Variables into a String

Since Python 3.6, a new powerful formatting mechanism was introduced.

This feature is formally named the Formatted String Literal, but is more usually referred to by its nickname f-string.

More about f-string see: f-string

Modify Strings

In a nutshell, you can’t. Strings are one of the data types Python considers immutable, meaning not able to be changed.

You can usually easily accomplish what you want by generating a copy of the original string that has the desired change in place. Two possibilities:

Assign a new string to the variable

>>> s = 'foobar'
>>> s = s[:3] + 'x' + s[4:]
>>> s
'fooxar'

Use built-in string method

>>> s = 'foobar'
>>> s = s.replace('b', 'x')
>>> s
'fooxar'

Built-in String Methods

Python provides a lot of useful built-in methods for string objects.

Function: a callable procedure that you can invoke to perform specific tasks.

Method: a specialized type of callable procedure that is tightly associated with an object. Like a function, a method is called to perform a distinct task, but it is invoked on a specific object and has knowledge of its target object during execution.

In the following method definitions, arguments specified in square brackets ([]) are optional.

Case Conversion

Methods in this group perform case conversion on the target string.

`s.capitalize()`

Returns a copy of s with the first character converted to uppercase and all other characters converted to lowercase. Non-alphabetic characters are unchanged.

Example

>>> s = 'foo123#BAR#.'
>>> s.capitalize()
'Foo123#bar#.'

`s.lower()`

Returns a copy of s with all alphabetic characters converted to lowercase.

`s.swapcase()`

Returns a copy of s with uppercase alphabetic characters converted to lowercase and vice versa.

Example

>>> 'FOO Bar 123 baz qUX'.swapcase()
'foo bAR 123 BAZ Qux'

`s.title()`

Returns a copy of s in which the first letter of each word is converted to uppercase and remaining letters are lowercase.

This method uses a fairly simple algorithm. It does NOT attempt to distinguish between important and unimportant words, and it does NOT handle apostrophes, possessives, or acronyms gracefully.

Example

>>> "what's happened to ted's IBM stock?".title()
"What'S Happened To Ted'S Ibm Stock?"

`s.upper()`

Returns a copy of s with all alphabetic characters converted to uppercase.

Find and Replace

These methods provide various means of searching the target string for a specified substring.
Each method in this group supports optional <start> and <end> arguments.
- The action of the method is restricted to the portion of the target string starting at character position <start> and proceeding up to but NOT including character position <end>
- If <start> is specified but <end> is not, the method applies to the portion of the target string from <start> through the end of the string.

`s.count([, <start>[, <end>]])`

Counts occurrences of a substring in the target string.
returns the number of non-overlapping occurrences of substring  in s:

Example

>>> 'foo goo moo'.count('oo')
3

>>> 'foo goo moo'.count('oo', 0, 8)
2

`s.endswith(<suffix>[, <start>[, <end>]])`

Determines whether the target string ends with a given substring
returns True if s ends with the specified <suffix> and False otherwise

Example

>>> 'foobar'.endswith('bar')
True
>>> 'foobar'.endswith('baz')
False

>>> 'foobar'.endswith('oob', 0, 4)
True
>>> 'foobar'.endswith('oob', 2, 4)
False

`s.find([, <start>[, <end>]])`

Searches the target string for a given substring. You can use .find() to see if a Python string contains a particular substring.
Returns the lowest index in s where substring  is found
Returns -1 if the specified substring is not found

Example

>>> 'foo bar foo baz foo qux'.find('foo')
0

>>> 'foo bar foo baz foo qux'.find('grault')
-1

>>> 'foo bar foo baz foo qux'.find('foo', 4)
8
>>> 'foo bar foo baz foo qux'.find('foo', 4, 7)
-1

`s.index([, <start>[, <end>]])`

Identical to .find(), except that it raises an exception if  is not found rather than returning -1

`s.rfind([, <start>[, <end>]])`

Searches the target string for a given substring starting at the end.
Returns the highest index in s where substring  is found
Returns -1 if the substring is not found

Example

>>> 'foo bar foo baz foo qux'.rfind('foo')
16

>>> 'foo bar foo baz foo qux'.rfind('grault')
-1

>>> 'foo bar foo baz foo qux'.rfind('foo', 0, 14)
8
>>> 'foo bar foo baz foo qux'.rfind('foo', 10, 14)
-1

`s.rindex([, <start>[, <end>]])`

Identical to .rfind(), except that it raises an exception if  is not found rather than returning -1

`s.startswith(<prefix>[, <start>[, <end>]])`

Determines whether the target string starts with a given substring.
Returns True if s starts with the specified <prefix> and False otherwise

Example

>>> 'foobar'.startswith('foo')
True
>>> 'foobar'.startswith('bar')
False

>>> 'foobar'.startswith('bar', 3)
True
>>> 'foobar'.startswith('bar', 3, 2)
False

Character Classification

Classify a string based on the characters it contains.

`s.isalnum()`

Determines whether the target string consists of alphanumeric characters
Returns True if s is nonempty and all its characters are alphanumeric (either a letter or a number), and False otherwise

Example

>>> 'abc123'.isalnum()
True
>>> 'abc$123'.isalnum()
False
>>> ''.isalnum()
False

`s.isalpha()`

Determines whether the target string consists of alphabetic characters.
s.isalpha() returns True if s is nonempty and all its characters are alphabetic, and False otherwise

Example

>>> 'ABCabc'.isalpha()
True
>>> 'abc123'.isalpha()
False

`s.isdigit()`

Determines whether the target string consists of digit characters. You can use the .isdigit() Python method to check if your string is made of only digits.
Returns True if s is nonempty and all its characters are numeric digits, and False otherwise

Example

>>> '123'.isdigit()
True
>>> '123abc'.isdigit()
False

`s.isidentifier()`

Determines whether the target string is a valid Python identifier.
Returns True if s is a valid Python identifier according to the language definition, and False otherwise

Example

>>> 'foo32'.isidentifier()
True
>>> '32foo'.isidentifier()
False
>>> 'foo$32'.isidentifier()
False

.isidentifier() will return True for a string that matches a Python keyword even though that would not actually be a valid identifier, e.g.,

>>> 'and'.isidentifier() # and is a keyword in python
True

To test whether a string matches a Python keyword, use keyword.iskeyword():

>>> from keyword import iskeyword
>>> iskeyword('and')
True

If you really want to ensure that a string would serve as a valid Python identifier, you should check that .isidentifier() is True and that iskeyword() is False

`s.islower()`

Determines whether the target string’s alphabetic characters are lowercase.
returns True if s is nonempty and all the alphabetic characters it contains are lowercase, and False otherwise. Non-alphabetic characters are ignore.

Example

>>> 'abc'.islower()
True
>>> 'abc1$d'.islower()
True
>>> 'Abc1$D'.islower()
False

`s.isprintable()`

Returns True if s is empty or all the alphabetic characters it contains are printable.
Returns False if s contains at least one non-printable character.
Non-alphabetic characters are ignored

Example

>>> 'a\tb'.isprintable()
False
>>> 'a b'.isprintable()
True
>>> ''.isprintable()
True
>>> 'a\nb'.isprintable()
False

This is the only .isxxxx() method that returns True if s is an empty string. All the others return False for an empty string.

`s.isspace()`

Determines whether the target string consists of whitespace characters.
Returns True if s is nonempty and all characters are whitespace characters, and False otherwise.
The most commonly encountered whitespace characters are
- space ' '
- tab '\t'
- newline '\n'

Example

>>> ' \t \n '.isspace()
True
>>> ' a '.isspace()
False

`s.istitle()`

Determines whether the target string is title cased.
Returns
- True if s is nonempty, the first alphabetic character of each word is uppercase, and all other alphabetic characters in each word are lowercase. (more intuitive: “Uppercase characters may only follow uncased characters and lowercase characters only cased ones.”)
- False, otherwise

Example

>>> 'This Is A Title'.istitle()
True
>>> 'This is a title'.istitle()
False
>>> 'Give Me The #$#@ Ball!'.istitle()
True

`s.isupper()`

Determines whether the target string’s alphabetic characters are uppercase.
Returns True if s is nonempty and all the alphabetic characters it contains are uppercase, and False otherwise.
Non-alphabetic characters are ignored

Example

>>> 'ABC'.isupper()
True
>>> 'ABC1$D'.isupper()
True
>>> 'Abc1$D'.isupper()
False

String Formatting

Modify or enhance the format of a string

`s.center(<width>[, <fill>])`

Centers a string in a field.
Returns a string consisting of s centered in a field of width <width>. By default, padding consists of the ASCII space character
```
>>> 'foo'.center(10)
' foo '
```
If the optional <fill> argument is specified, it is used as the padding character
```
>>> 'bar'.center(10, '-')
'---bar----'
```
If s is already at least as long as <width>, it is returned unchanged
```
>>> 'foo'.center(2)
'foo'
```

`s.expandtabs(tabsize=8)`

Replaces each tab character ('\t') with spaces.
tabsize is an optional keyword parameter specifying alternate tab stop columns. By default, spaces are filled in assuming a tab stop at every eighth column

Example

>>> 'a\tb\tc'.expandtabs()
'a b c'
>>> 'aaa\tbbb\tc'.expandtabs()
'aaa bbb c'

>>> 'a\tb\tc'.expandtabs(4)
'a b c'
>>> 'aaa\tbbb\tc'.expandtabs(tabsize=4)
'aaa bbb c'

`s.ljust(<width>[, <fill>])`

Left-justifies a string in field.
Returns a string consisting of s left-justified in a field of width <width>
```
>>> 'foo'.ljust(10)
'foo '
```
If the optional <fill> argument is specified, it is used as the padding character
```
>>> 'foo'.ljust(10, '-')
'foo-------'
```
If s is already at least as long as <width>, it is returned unchanged
```
>>> 'foo'.ljust(2)
'foo'
```

`s.lstrip([<chars>])`

Trims leading characters from a string.

returns a copy of s with any whitespace characters removed from the left end

>>> ' foo bar baz '.lstrip()
'foo bar baz '
>>> '\t\nfoo\t\nbar\t\nbaz'.lstrip()
'foo\t\nbar\t\nbaz'

If the optional <chars> argument is specified, it is a string that specifies the set of characters to be removed
```
>>> 'http://www.realpython.com'.lstrip('/:pth')
'www.realpython.com'
```

`s.replace(<old>, <new>[, <count>])`

Replaces occurrences of a substring within a string.

Returns a copy of s with all occurrences of substring <old> replaced by <new>

>>> 'foo bar foo baz foo qux'.replace('foo', 'grault')
'grault bar grault baz grault qux'

If the optional <count> argument is specified, a maximum of <count> replacements are performed, starting at the left end of s
```
>>> 'foo bar foo baz foo qux'.replace('foo', 'grault', 2)
'grault bar grault baz foo qux'
```

`s.rjust(<width>[, <fill>])`

Right-justifies a string in a field.
Works similarly to s.ljust()

`s.rstrip([<chars>])`

Trims trailing characters from a string.
Works similarly to s.lstrip()

`s.strip([<chars>])`

Strips characters from the left and right ends of a string.
Equivalent to s.lstrip().rstrip()
As with .lstrip() and .rstrip(), the optional <chars> argument specifies the set of characters to be removed

`s.zfill(<width>)`

Pads a string on the left with zeros.
Returns a copy of s left-padded with '0' characters to the specified <width>
```
>>> '42'.zfill(5)
'00042'
```
If s contains a leading sign, it remains at the left edge of the result string after zeros are inserted
```
>>> '+42'.zfill(8)
'+0000042'
>>> '-42'.zfill(8)
'-0000042'
```
If s is already at least as long as <width>, it is returned unchanged

Converting Between Strings and Lists

Convert between a string and some composite data type by either pasting objects together to make a string, or by breaking a string up into pieces.

`s.join(<iterable>)`

Concatenates strings from an iterable.

Example

>>> ', '.join(['foo', 'bar', 'baz', 'qux'])
'foo, bar, baz, qux'

In the following example, <iterable> is specified as a single string value. When a string value is used as an iterable, it is interpreted as a list of the string’s individual characters.

>>> list('corge')
['c', 'o', 'r', 'g', 'e']

>>> ':'.join('corge')
'c:o:r:g:e'

`s.partition(<sep>)`

Splits s at the first occurrence of string <sep>.
The return value is a three-part tuple consisting of:
- The portion of s preceding <sep>
- <sep> itself
- The portion of s following <sep>

Example

>>> 'foo.bar'.partition('.')
('foo', '.', 'bar')
>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')

If <sep> is not found in s, the returned tuple contains s followed by two empty strings:

>>> 'foo.bar'.partition('@@')
('foo.bar', '', '')

s.rpartition()

Works exactly like s.partition(<sep>), except that s is split at the last occurrence of <sep> instead of the first occurrence

`s.rsplit(sep=None, maxsplit=-1)`

Splits a string into a list, starting from the right

Without arguments, s.rsplit() splits s into substrings delimited by any sequence of whitespace and returns the substrings as a list

>>> 'foo bar baz qux'.rsplit()
['foo', 'bar', 'baz', 'qux']
>>> 'foo\n\tbar baz\r\fqux'.rsplit()
['foo', 'bar', 'baz', 'qux']

If <sep> is specified, it is used as the delimiter for splitting
```
>>> 'foo.bar.baz.qux'.rsplit(sep='.')
['foo', 'bar', 'baz', 'qux']
```
- When <sep> is explicitly given as a delimiter, consecutive delimiters in s are assumed to delimit empty strings, which will be returned
```
>>> 'foo...bar'.rsplit(sep='.')
['foo', '', '', 'bar']
```
If the optional keyword parameter <maxsplit> is specified, a maximum of that many splits are performed, starting from the right end of s
```
>>> 'www.realpython.com'.rsplit(sep='.', maxsplit=1)
['www.realpython', 'com']
```

`s.split(sep=None, maxsplit=-1)`

Behaves exactly like s.rsplit(), except that if <maxsplit> is specified, splits are counted from the left end of s rather than the right end

`s.splitlines([<keepends>])`

Splits s at line boundaries up into lines and returns them in a list.

Any of the following characters or character sequences is considered to constitute a line boundary:

Escape Sequence	Character
`\n`	Newline
`\r`	Carriage Return
`\r\n`	Carriage Return + Line Feed
`\v` or `\x0b`	Line Tabulation
`\f` or `\x0c`	Form Feed
`\x1c`	File Separator
`\x1d`	Group Separator
`\x1e`	Record Separator
`\x85`	Next Line (C1 Control Code)
`\u2028`	Unicode Line Separator
`\u2029`	Unicode Paragraph Separator

Advanced

Substring count with overlapping occurrences

Let’s say we want to count the occurrence of substring 11 in the string 1011101111.

Note that in Python, the count() method returns the number of substrings in a given string, but it does not give correct results when two occurrences of the substring overlap. However, we still have different solution for this problem.

string = "1011101111"
sub_string = "11"

Use built-in `re` module

import re

Use [re.findall()](https://docs.python.org/3/library/re.html#re.findall):

>>> len(re.findall(f"(?={sub_string})", string))
5

Use re.subn :

>>> re.subn(f"(?={sub_string})", "", string)[1]
5

Use built-in string methods

Use startswith():

def count_substring(string, sub_string):
 count = 0
 for pos in range(len(string)):
 if string[pos:].startswith(sub_string):
 count += 1
 return count

>>> count_substring(string, sub_string)
5

Or in a more pythonic way, use list comprehension:

sum([string.startswith(sub_string, i) for i in range(len(string))])

Reference

String count with overlapping occurrences

Reference

Strings and Character Data in Python

f-string

Wed, 21 Oct 2020 00:00:00 +0000

Python f-string is the newest Python syntax to do string formatting. Python f-strings provide a faster, more readable, more concise, and less error prone way of formatting strings in Python. 👏

The f-strings have the f prefix and use {} brackets to evaluate values.

Python string formatting

The following example summarizes string formatting options in Python:

name = 'Peter'
age = 23

print('%s is %d years old' % (name, age)) # C style
print('{} is {} years old'.format(name, age)) # python format function
print(f'{name} is {age} years old') # f-string

Peter is 23 years old
Peter is 23 years old
Peter is 23 years old

f-string usage

f-string expressions

We can put expressions between the {} brackets, and the expression will be evaluated inside f-string

bags = 3
apples_in_bag = 12

print(f'There are total of {bags * apples_in_bag} apples')

There are total of 36 apples

f-string dictionaries

user = {'name': 'John Doe', 'occupation': 'gardener'}

print(f"{user['name']} is a {user['occupation']}")

John Doe is a gardener

f-string debug

Python 3.8 introduced the self-documenting expression with the = character.

import math

x = 0.8

print(f'{math.cos(x) = }')
print(f'{math.sin(x) = }')

math.cos(x) = 0.6967067093471654
math.sin(x) = 0.7173560908995228

multiline f-string

The f-strings are placed between round brackets
Each of the strings is preceded with the f character

name = 'John Doe'
age = 32
occupation = 'gardener'

msg = (
 f'Name: {name}\n'
 f'Age: {age}\n'
 f'Occupation: {occupation}'
)

print(msg)

Name: John Doe
Age: 32
Occupation: gardener

f-string calling function

def mymax(x, y):
 return x if x > y else y

a = 3
b = 4

print(f'Max of {a} and {b} is {mymax(a, b)}')

Max of 3 and 4 is 4

f-string objects

Python f-string accepts objects as well; the objects must have either __str__() or __repr__() magic functions defined.

class User:
 def __init__(self, name, occupation):
 self.name = name
 self.occupation = occupation

 def __repr__(self):
 return f"{self.name} is a {self.occupation}"

u = User('John Doe', 'gardener')

print(f'{u}')

John Doe is a gardener

f-string format

floats

Floating point values have the f suffix. We can also specify the precision: the number of decimal places. The precision is a value that goes right after the dot character.

val = 12.3

print(f'{val:.2f}')
print(f'{val:.5f}')

12.30
12.30000

width

The width specifier sets the width of the value. The value may be filled with spaces or other characters if the value is shorter than the specified width.

for x in range(1, 11):
 print(f'{x:02} {x*x:3} {x*x*x:4}')

01 1 1
02 4 8
03 9 27
04 16 64
05 25 125
06 36 216
07 49 343
08 64 512
09 81 729
10 100 1000

We can combine floats precision and width, for example:

import numpy as np

a = np.random.rand(20)

for index, value in enumerate(a):
 if index < 10:
 print(f'{index:2}: {value:4.4f}')
 else:
 print(f'{index:2}: {value:4.3f}')

{value:4.4f} means

We will use a width of 4-character to print value
The precision of value is 4: we will keep 4 decimal places

`!r`, `!s`, and `!a`

The conversions !r, !s, and !a are equivalent to calling repr(), str(), and ascii(), respectively.

Example:

>> a = 'some string'
>>> f'{a!r}'
"'some string'"

is identical to

>>> f'{repr(a)}'
"'some string'"

The usage of these conversion are not strictly required, because explicitly calling the corresponding functions is arguably more clear in its intent. In other words, they are redundant.

!r (repr), !s (str) and !a (ascii) are kept around just to ease compatibility with the str.format() alternative, because it does not allow the execution of arbitrary expressions. You don’t need to use them with f-strings.

Reference:

Reference

Python f-string tutorial

String | Haobin Tan

String

String Operators

The + Operator

The * Operator

The in Operator

Build-in String Functions

ord(c)

chr(n)

len(s)

str(obj)

List Operations for String

Interpolating Variables into a String

Modify Strings

Built-in String Methods

Case Conversion

s.capitalize()

s.lower()

s.swapcase()

s.title()

s.upper()

Find and Replace

s.count(<sub>[, <start>[, <end>]])

s.endswith(<suffix>[, <start>[, <end>]])

s.find(<sub>[, <start>[, <end>]])

s.index(<sub>[, <start>[, <end>]])

s.rfind(<sub>[, <start>[, <end>]])

s.rindex(<sub>[, <start>[, <end>]])

s.startswith(<prefix>[, <start>[, <end>]])

Character Classification

s.isalnum()

s.isalpha()

s.isdigit()

s.isidentifier()

s.islower()

s.isprintable()

s.isspace()

s.istitle()

s.isupper()

String Formatting

s.center(<width>[, <fill>])

s.expandtabs(tabsize=8)

s.ljust(<width>[, <fill>])

s.lstrip([<chars>])

s.replace(<old>, <new>[, <count>])

s.rjust(<width>[, <fill>])

s.rstrip([<chars>])

s.strip([<chars>])

s.zfill(<width>)

Converting Between Strings and Lists

s.join(<iterable>)

s.partition(<sep>)

s.rpartition()

s.rsplit(sep=None, maxsplit=-1)

s.split(sep=None, maxsplit=-1)

s.splitlines([<keepends>])

Advanced

Substring count with overlapping occurrences

Use built-in re module

Use built-in string methods

Reference

Reference

f-string

Python string formatting

f-string usage

f-string expressions

f-string dictionaries

f-string debug

multiline f-string

f-string calling function

f-string objects

f-string format

floats

width

!r, !s, and !a

Reference

The `+` Operator

The `*` Operator

The `in` Operator

`ord(c)`

`chr(n)`

`len(s)`

`str(obj)`

`s.capitalize()`

`s.lower()`

`s.swapcase()`

`s.title()`

`s.upper()`

`s.count(<sub>[, <start>[, <end>]])`

`s.endswith(<suffix>[, <start>[, <end>]])`

`s.find(<sub>[, <start>[, <end>]])`

`s.index(<sub>[, <start>[, <end>]])`

`s.rfind(<sub>[, <start>[, <end>]])`

`s.rindex(<sub>[, <start>[, <end>]])`

`s.startswith(<prefix>[, <start>[, <end>]])`

`s.isalnum()`

`s.isalpha()`

`s.isdigit()`

`s.isidentifier()`

`s.islower()`

`s.isprintable()`

`s.isspace()`

`s.istitle()`

`s.isupper()`

`s.center(<width>[, <fill>])`

`s.expandtabs(tabsize=8)`

`s.ljust(<width>[, <fill>])`

`s.lstrip([<chars>])`

`s.replace(<old>, <new>[, <count>])`

`s.rjust(<width>[, <fill>])`

`s.rstrip([<chars>])`

`s.strip([<chars>])`

`s.zfill(<width>)`

`s.join(<iterable>)`

`s.partition(<sep>)`

`s.rsplit(sep=None, maxsplit=-1)`

`s.split(sep=None, maxsplit=-1)`

`s.splitlines([<keepends>])`

Use built-in `re` module

`!r`, `!s`, and `!a`