Strings: Advanced

.split() divides a string into a list of substrings based on a delimiter. By default, it splits on whitespace (spaces, tabs, newlines).

This produces ['Python', 'is', 'a', 'powerful', 'language'] with 5 elements. The split() method returns a list.

The optional maxsplit parameter limits how many splits occur:

.splitlines() splits on line boundaries, handling different line ending conventions (\n, \r\n, \r):

row = "name,age,city"
fields = row.___(",")
print(fields)
print(___(fields))

The split() and join() methods are complementary: split() turns a string into a list, and join() turns a list back into a string. Together they form the split-transform-join pattern, which is one of the most common string processing idioms in Python.

Calling split() without arguments splits on any whitespace and discards empty strings caused by consecutive spaces. Calling split(" ") splits only on single spaces and preserves empty strings between adjacent spaces.

.join() is the opposite of split(). It combines a list of strings into a single string, inserting the separator between each element.

Note that .join() is called on the separator, not the list. This syntax seems backwards at first but makes sense because the separator is a string method.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

colors = ["red", "green", "blue"]
result = colors.join("-")
print(result)

split() without arguments splits on any whitespace and removes empty strings. Joining with a single space normalizes the spacing.

var_name = "first_name"
result = " ".join(word.capitalize() for word in var_name.split(___"_"" "","))
print(result)

String case conversions include lower(), upper(), capitalize() (first letter only), and title() (first letter of every word). For custom casing logic like snake_case to CamelCase, split-transform-join gives you full control over each word.

< left-aligns, > right-aligns, ^ centers. The number specifies total width. Optional fill character (like *) pads the empty space.

The % format multiplies by 100 and adds the % sign. The e format uses scientific notation.

price = 1234.5
print(f"{price:______}")
print(f"{price:.0f}")

F-string format specifiers follow the pattern {value:[[fill]align][sign][#][0][width][grouping][.precision][type]}. For most everyday formatting, only a few parts are needed: width for padding, .precision for decimals, , for thousands, and f or d for the type.

Number formatting in f-strings is consistent and composable. The comma and precision specifiers combine naturally: {price:,.2f} produces exactly the format used in financial reports, with thousands separated and two decimal places.

Python has two types for text-like data: str (Unicode strings) and bytes (raw byte sequences). They are not interchangeable.

The b prefix creates a bytes object. Strings are for text; bytes are for binary data like files, network data, or images.

.encode() converts a string to bytes. .decode() converts bytes back to a string.

For ASCII characters, the string length and byte length are the same. But for international characters, len() counts characters while the encoded byte length can be 2-4x larger. This difference matters when you work with file sizes, network buffers, or database column limits.

errors="replace" substitutes invalid bytes with a replacement character. errors="ignore" skips invalid bytes entirely.

Choosing the right string processing tool, whether split, slicing, or regex, depends on the structure of your data. Delimiter-based data is easiest to handle with split(). Fixed-width data suits slicing. Variable-structure or pattern-based data calls for regular expressions.