Strings: Beginner

text = ___"'It's Python___"'
print(text)

The \n escape sequence creates a new line. When you print the multiline string above, it will display on three separate lines.

A critical concept in Python: the string "42" is completely different from the number 42. They look similar when printed, but they behave differently in your code.

The first print outputs 52 (mathematical addition). The second outputs "4210" (string concatenation). The + operator does different things depending on the data types involved.

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

message = "Score: " + 100
print(message)

str() converts any value to its string representation. int() and float() convert strings to numbers (if the string contains valid numeric characters).

Concatenation means joining strings together. The + operator combines two strings into one, placing them end-to-end.

This outputs: "Order: 2x Laptop at $999.99". Notice how we converted numbers to strings with str() before concatenating.

The * operator repeats a string a specified number of times:

result = "Ha" ___+* ___"Ha"3
print(result)

String concatenation with + builds new strings by joining two existing ones end-to-end. Each + operation creates a brand new string object. For joining many strings in a loop, this can be slow; using "".join(list_of_strings) is far more efficient for bulk assembly.

The * operator repeats a string a fixed number of times, which is useful for generating separators, padding, or simple repeated patterns without writing a loop.

The len() function returns the number of characters in a string. It counts every character, including spaces and punctuation.

len() is commonly used for validation and loop control:

Both approaches work. The second is more "Pythonic" because empty strings are falsy in Python (they evaluate to False in boolean contexts).

username = "alice"
n = ___(username)
if n >= 3 and n ___ 10:
    print("Valid")
else:
    print("Invalid")
print(len(username))

len() is one of Python's most-used built-in functions for strings. It counts every character including spaces, punctuation, and newline characters. Understanding the exact count is important for validation, truncation, and formatted output.

Empty strings have length 0 and are falsy in Python, so if not user_input: is an idiomatic way to check for an empty string. Both len(s) == 0 and not s are correct, but the latter is considered more Pythonic.

.lower() converts all letters to lowercase. .upper() converts all letters to uppercase. Neither method affects non-letter characters.

Outputs: "Alice johnson", "Alice Johnson", and "AlIcE jOhNsOn" respectively. The title() method is especially useful for formatting names and headings.

answer = "YES"
if answer.___loweruppertitle() == "yes":
    print("Match!")

This does not change the original "Alice" string. Instead, it creates a new string "ALICE" and assigns it to the variable name. The original "Alice" string still exists in memory until Python removes it.

This raises a TypeError. To "change" a character, you must create a new string:

This creates "Jello" by concatenating "J" with everything from position 1 onward using the slice text[1:]. We'll cover string slicing in detail in the intermediate lesson.

Safe as dictionary keys

Immutable objects can be hashed and used as dictionary keys reliably.

Safe variable sharing

Multiple variables can point to the same string without risk of accidental changes.

String interning

Python can reuse identical string objects in memory to save space.

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

name = "alice"
name.upper()
print(name)

Case conversion methods like upper(), lower(), and title() are frequently used to normalize user input before comparison. Comparing answer.lower() == "yes" correctly matches "YES", "Yes", and "yes" without needing separate conditions.