my_string = "Hello, World!"

first_name = "John"
last_name = "Doe"
full_name = first_name + " " + last_name

my_string = "Python is amazing"
substring = my_string[7:13]

name = "Alice"
age = 30
formatted_string = f"Hello, my name is {name} and I'm {age} years old."

Raw Strings

Raw strings are prefixed with r and are used when you want to treat backslashes as literal characters, which is useful in regular expressions and file paths.

path = r'C:\Users\Username\Documents'

Common String Errors

SyntaxError

A common error occurs when you don’t properly close a string with the same type of quotes it started with.

message = "This is a syntax error.'

NameError

Using a variable that hasn’t been defined can lead to a NameError.

print(unknown_variable)

TypeError

Attempting to combine incompatible types can result in a TypeError.

age = 30
message = "I am " + age + " years old."

Strings in Python 2 vs. Python 3

Strings in Python 2 and Python 3 have some important differences. Here’s a comparison:

1. Unicode by Default:
   • Python 2: In Python 2, strings are represented as sequences of bytes by default. To work with Unicode characters, you need to use the unicode type explicitly.
   • Python 3: Python 3, on the other hand, represents strings as sequences of Unicode characters by default. The str type in Python 3 is essentially the Unicode string, and there is a separate bytes type for dealing with byte sequences.
2. String Literals:
   • Python 2: String literals are defined with either single (') or double (") quotes. Unicode strings are indicated with a u prefix (e.g., u"unicode string").
   • Python 3: String literals can still be defined with single or double quotes, but there’s no need for a u prefix to create Unicode strings. All string literals are Unicode by default.
3. Print Statement:
   • Python 2: The print statement is used for printing, and it doesn’t require parentheses. You can use % formatting for string interpolation.
   • Python 3: The print() function is used for printing in Python 3, and it requires parentheses. String interpolation is typically done using f-strings (e.g., f"Hello, {name}") or the str.format() method.
4. String Encoding and Decoding:
   • Python 2: You often need to manually encode and decode strings when working with different encodings. Common functions for this purpose are str.encode() and unicode.decode().
   • Python 3: Python 3 emphasizes clarity and enforces explicit encoding/decoding. You use str.encode() to encode a string and bytes.decode() to decode bytes into a string.
5. Iteration over Characters:
   • Python 2: Iterating over a string using a for loop would give you individual bytes, not characters. To work with characters, you often had to use external libraries like unicode_literals.
   • Python 3: Iterating over a string using a for loop gives you individual characters, making it more intuitive for Unicode text processing.
6. Comparing Strings:
   • Python 2: Strings of different types (byte strings and Unicode strings) could be compared without raising an exception. This could lead to subtle bugs.
   • Python 3: Comparing byte strings and Unicode strings without explicit conversion raises a TypeError.
7. String Methods:
   • Python 2: String methods were mostly byte-oriented and had limited Unicode support.
   • Python 3: String methods in Python 3 are Unicode-aware and work seamlessly with different character encodings.
8. Unicode Support:
   • Python 2: Unicode support was not as strong, and working with non-ASCII characters could be challenging.
   • Python 3: Python 3 has robust Unicode support, making it much easier to work with international text.

Python 3 introduced significant improvements in string handling, especially regarding Unicode support, making it the preferred choice for modern string processing tasks. Python 2 is now outdated and no longer maintained, so it’s strongly recommended to migrate to Python 3 for new projects.