1. Single and Double Quotes#

Single and double quotes both create values of type str. They behave exactly the same:

1
name1 = 'Bob'
2
name2 = "Bob"
3

4
print(name1 == name2)  # True

Choose the style that makes the text easiest to read and requires the fewest escapes:

1
text1 = "I'm Bob"
2
text2 = 'She said, "Hello."'

If the content contains the same quote used to define the string, escape it with a backslash:

1
text = 'I\'m Bob'
2
print(text)  # I'm Bob

Most projects adopt one quote style for consistency and switch only when it improves readability.

2. Triple Quotes and Multiline Strings#

Three single quotes (''') or three double quotes (""") create a string that can span several lines:

1
text = """First line
2
Second line
3
Third line"""
4

5
print(text)

Triple-quoted strings are useful for:

• Multiline text
• SQL or HTML fragments
• Module, class, function, and method docstrings

1
def add(a, b):
2
    """Return the sum of two numbers."""
3
    return a + b

Triple quotes do not remove indentation or leading and trailing line breaks. If indentation affects the result, use textwrap.dedent() from the standard library.

3. Escape Sequences#

A backslash gives the following character a special meaning. These are some common escape sequences:

1
print('Name: Bob\nAge: 18')

Output:

1
Name: Bob
2
Age: 18

4. f-Strings: The Preferred Choice for Modern Python#

Add f or F before a string to insert values or expressions inside {}. Python introduced f-strings in version 3.6:

1
name = 'Bob'
2
age = 18
3

4
text = f'Name: {name}, age: {age}'
5
print(text)

The braces can contain expressions, including function and method calls:

1
a = 10
2
b = 20
3
name = 'bob'
4

5
print(f'{a} + {b} = {a + b}')  # 10 + 20 = 30
6
print(f'Name: {name.upper()}')   # Name: BOB

A colon after the expression introduces a format specifier:

1
{expression:format_specifier}

1
price = 12.3456
2
money = 1_234_567
3
rate = 0.856
4

5
print(f'{price:.2f}')  # 12.35
6
print(f'{money:,}')    # 1,234,567
7
print(f'{rate:.1%}')   # 85.6%

1
number = 7
2
print(f'{number:03d}')  # 007

1
name = 'Bob'
2

3
print(f'|{name:<10}|')  # Left-aligned
4
print(f'|{name:^10}|')  # Centered
5
print(f'|{name:>10}|')  # Right-aligned

1
|Bob       |
2
|   Bob    |
3
|       Bob|

1
print(f'|{name:-<10}|')  # |Bob-------|
2
print(f'|{name:-^10}|')  # |---Bob----|
3
print(f'|{name:->10}|')  # |-------Bob|

1
print(f'{"Name":<10}{"Age":>5}')
2
print(f'{"Bob":<10}{18:>5}')
3
print(f'{"Alice":<10}{20:>5}')

1
name = 'Bob'
2

3
print(f'{name}')    # Bob
4
print(f'{{name}}')  # {name}

1
items = 3
2
price = 12.5
3

4
print(f'{items=}, {price=}, {items * price=}')

1
items=3, price=12.5, items * price=37.5

5. Raw Strings: The r Prefix#

The r or R prefix creates a raw string. Backslashes in its literal text are generally preserved:

1
normal = 'hello\nworld'
2
raw = r'hello\nworld'
3

4
print(normal)
5
print(raw)

Output:

1
hello
2
world
3
hello\nworld

Raw strings are especially useful for regular expressions:

1
import re
2

3
pattern = re.compile(r'\d+\.\d+')

They can also make Windows paths easier to read:

1
path = r'C:\Users\Bob\Desktop'

However, “raw” does not mean that backslashes play no role during parsing:

• A raw string cannot end with an odd number of consecutive backslashes.
• A quote matching the outer delimiter must still be protected with a backslash; that backslash remains in the result.
• A raw string does not turn a real line break into the two characters \n.

The following code is invalid:

1
# SyntaxError: the string ends with a single backslash
2
path = r'C:\Users\Bob\'

If a path must end with a backslash, join it with a regular string. Better still, use pathlib.Path for file-system paths.

6. Byte Literals: The b Prefix#

The b or B prefix creates bytes, not str:

1
text = 'Hello'
2
data = b'Hello'
3

4
print(type(text))  # <class 'str'>
5
print(type(data))  # <class 'bytes'>

The two types serve different purposes:

• str represents Unicode text.
• bytes represents byte values from 0 to 255, used for network protocols, binary files, images, audio, compression, and cryptography.

Convert text to bytes with an explicit encoding, and decode the bytes with the matching encoding:

1
text = 'Hello, Python!'
2
data = text.encode('utf-8')
3
restored = data.decode('utf-8')
4

5
print(data)      # b'Hello, Python!'
6
print(restored)  # Hello, Python!

The source text of a byte literal may contain only ASCII characters. For example, b'你好' is invalid. Encode a str instead, or use \xhh escapes to specify exact byte values.

7. Unicode and the u Prefix#

Regular strings are already Unicode strings in Python 3, so these forms are equivalent:

1
text1 = u'Hello'
2
text2 = 'Hello'

The u prefix mainly remains for compatibility with older code that once supported Python 2 and Python 3. New Python 3 code rarely needs it.

8. Combining String Prefixes#

1
name = 'Bob'
2
path = rf'C:\Users\{name}\Desktop'
3

4
print(path)  # C:\Users\Bob\Desktop

1
import re
2

3
word = 'hello'
4
pattern = re.compile(rf'\b{re.escape(word)}\b')

1
data1 = br'\n'
2
data2 = rb'\n'
3

4
print(data1)  # b'\\n'
5
print(data2)  # b'\\n'

9. Other Formatting Styles#

1
name = 'Bob'
2
age = 18
3

4
text1 = 'Name: {}, age: {}'.format(name, age)
5
text2 = 'Name: {name}, age: {age}'.format(name=name, age=age)
6
price = 'Price: {:.2f}'.format(12.3456)

1
name = 'Bob'
2
age = 18
3
price = 12.3456
4

5
print('Name: %s, age: %d' % (name, age))
6
print('Price: %.2f' % price)

1
import logging
2

3
logging.info('User %s logged in', name)

10. Everyday String Methods#

Strings are immutable. The following methods return new strings; they do not modify the original value.

1
text = 'Hello World'
2

3
print(text.lower())  # hello world
4
print(text.upper())  # HELLO WORLD
5
print(text.title())  # Hello World

1
text = '  hello  '
2

3
print(text.strip())
4
print(text.lstrip())
5
print(text.rstrip())

1
text = 'Hello Bob'
2
result = text.replace('Bob', 'Alice')
3

4
print(result)  # Hello Alice

1
text = 'apple,banana,orange'
2
fruits = text.split(',')
3

4
print(fruits)            # ['apple', 'banana', 'orange']
5
print(','.join(fruits))  # apple,banana,orange

1
text = 'Hello Python'
2

3
print(text.startswith('Hello'))  # True
4
print(text.endswith('Python'))    # True
5
print('Python' in text)           # True

11. Choosing the Right Form#

The main forms can be summarized in a few lines:

1
'hello'                    # Regular string
2
"hello"                    # Regular string
3
"""multiline string"""     # Multiline string
4
f'hello {name}'            # Formatted string
5
r'\d+\.\d+'                # Raw string, often used for regex
6
b'hello'                   # Byte literal
7
rf'\b{re.escape(name)}\b'  # Raw and formatted string

The choice becomes straightforward once you separate the decisions. First decide whether you are working with text or bytes. Then ask whether you need escapes, multiple lines, or interpolation. From there, choose the simplest form that expresses your intent clearly.