Skip to content

Data Type 2. – String

Strings are a fundamental and versatile data type in Python, crucial for dealing with textual data. This comprehensive guide will explore Python strings in-depth, covering their creation, manipulation, unique features, and best practices.

String Storage in Python

  1. ASCII (American Standard Code for Information Interchange):
    • Uses 7 bits to represent characters, allowing for 128 unique characters.
    • Primarily covers the English alphabet, numerals, and special characters.
  2. Unicode:
    • A character encoding standard that assigns a unique code point (numerical value) to each character, regardless of the platform or program.
    • Modern programming languages like Python store strings as Unicode to support a wide range of characters from various writing systems.
  3. Unicode Transformation Formats (UTF):
    • Standards to encode Unicode characters into binary data.
    • UTF-8:
      • Variable-width encoding, using 8, 16, 24, or 32 bits (1 to 4 bytes) per character.
      • It’s the most widely used and efficient for English and most other common languages.
    • UTF-16:
      • Uses 16 or 32 bits (2 or 4 bytes) per character.
      • Commonly used for representing characters that are outside the ASCII range.
    • UTF-32:
      • Uses a fixed 32 bits (4 bytes) per character.
      • Provides a direct representation of each Unicode code point.

In Python, UTF-8 is the default encoding for string storage, offering a balance between efficiency and versatility. UTF-8 is particularly efficient for English and other commonly used characters, as it uses a single byte for them (same as ASCII), but can also represent a vast range of characters from various languages and symbols.

Additionally, the first 127 Unicode code points correspond exactly to ASCII, ensuring compatibility and smooth transition from ASCII to Unicode.

Understanding these encoding standards is crucial for working with strings effectively, especially in a global context where multilingual support and consistent handling of text are essential.

1. Introduction to Strings

In Python, a string is a sequence of characters, typically used to represent textual data. It can include letters, numbers, symbols, and even whitespace. Strings are incredibly versatile and form the basis for text processing in most programs.

str_single = 'This is a single-quoted string.'
str_double = "This is a double-quoted string."
str_triple = '''This is a triple-quoted string.'''

2. Creating Strings

  • Single Quotes (‘ ‘):
    • Preferred for strings that may contain double quotes (” “) within them.
    • Useful for strings that don’t contain apostrophes (‘) to enhance readability.
  • Double Quotes (” “):
    • Preferred for strings that may contain apostrophes (‘) within them.
    • Useful for strings that don’t contain double quotes (“) to enhance readability.
  • Triple Quotes (”’ ”’ or “”” “””):
    • Used for creating multiline strings, allowing line breaks without using escape characters like ‘\n’.
    • Ideal for longer strings that span multiple lines.

For example:

single_quotes_str = 'He said, "Python is great!"'
double_quotes_str = "He said, 'Python is great!'"
multiline_str = '''This is a
multiline string.'''

3. String Operations

a. Iteration

Python strings are iterable, meaning you can loop through the characters in a string using various iteration constructs like for loops. This property allows you to access and process each character or a subset of characters in a string easily.

Here’s a simple example demonstrating string iteration:

my_string = "Hello, World!"

# Iterating through each character
for char in my_string:
    print(char)

# Iterating through a subset of characters
for i in range(0, len(my_string), 2):
    print(my_string[i])


H
e
l
l
o
,
 
W
o
r
l
d
!

Iterating through a subset of characters with a step of 3:
for i in range(0, len(my_string), 2):
    print(my_string[i])


H
l
o
,
o
l
!

b. String Indexing and Slicing

Strings are indexed, meaning each character in a string can be accessed using its index. Indexing starts from 0 for the first character, and you can use negative indices to count from the end of the string.

Indexing:
a = "Hello World"
# One way to access the character is positive indexing and other is negative
# Let's try with an example - Get the third character from first and third from last element in the string
print("Third from first: " + a[2] + ", Third from last: " + a[-3]) # Starts from 0 but in reverse starts from -1

Third from first: l, Third from last: r

Slicing:
# Getting a substring
# Getting a part of string
print(a[3:])
print(a[:3])
print(a[1:6])
print(a[1:6:2])
print(a[1])
print(a[::-1]) # Returns the reverse of the string

lo World
Hel
ello 
el 
e
dlroW olleH

c. Concatenation (+)

The + operator is used to concatenate or join two or more strings together, creating a new string that contains the combined characters from the original strings.

str1 = "Hello, "
str2 = "World!"
concatenated_str = str1 + str2
print(concatenated_str)


Hello, World!

d. Repetition (*)

The * operator, when used with a string and an integer, repeats the string a specified number of times, creating a new string with the original string repeated accordingly.

original_str = "Python "
repeated_str = original_str * 3
print(repeated_str)


Python Python Python

e. Comparison Operators

  1. == (Equality Operator):
    • Checks if two strings are exactly equal, character by character.
  2. != (Inequality Operator):
    • Checks if two strings are not equal.
  3. < (Less Than Operator):
    • Checks if the first string comes before the second string in lexicographical order.
  4. > (Greater Than Operator):
    • Checks if the first string comes after the second string in lexicographical order.
  5. <= (Less Than or Equal To Operator):
    • Checks if the first string is less than or equal to the second string in lexicographical order.
  6. >= (Greater Than or Equal To Operator):
    • Checks if the first string is greater than or equal to the second string in lexicographical order.
str1 = "hello"
str2 = "world"

print(str1 == str2)  # Output: True
print(str1 != str2)  # Output: False
print(str1 < str2)  # Output: True
print(str1 > str2)  # Output: False
print(str1 <= str2)  # Output: True
print(str1 >= str2)  # Output: False

True
False
True
False
True
False

Lexicographical order is based on the Unicode code points of the characters in the strings. When comparing strings character by character, the comparison starts from the leftmost character of each string. If two characters at the same position have different Unicode code points, the string with the smaller Unicode code point is considered “less” in lexicographical order.

For example, comparing “apple” and “banana”:

  • ‘a’ (97) comes before ‘b’ (98), so “apple” is less than “banana”.

In Python, uppercase letters have smaller Unicode code points than their lowercase counterparts. As a result, when comparing the uppercase and lowercase versions of the same alphabet, the uppercase letters are considered “less” than the lowercase letters.

For example, comparing “apple” and “Apple”:

  • ‘A’ (65) comes before ‘a’ (97), so “Apple” is less than “apple”.

4. String Functions

Python provides a variety of built-in functions that are specifically designed to work with strings. Here are some important built-in functions commonly used with strings:

  1. len()
    • len() Returns the length (number of characters) of a string.
  2. str()
    • str() Converts an object into a string.
  3. min() and max()
    • min() returns the smallest element in a string (based on ASCII values).
    • max() returns the largest element in a string (based on ASCII values).
  4. sorted()
    • sorted() returns a sorted list of the specified string or any iterable.
  5. ord()
    • The ord() function takes a character (a string of length 1) and returns its Unicode code point as an integer.
  6. chr()
    • The chr() function takes a Unicode code point (an integer) and returns the corresponding character.
string = "hello"
num = 54

print(len(string))  # Output: 5

str_num = str(num)
print(str_num, type(str_num)) # Output: 54, <class 'str'>

print(min(string))  # Output: 'e'
print(max(string))  # Output: 'o'

sorted_string = sorted(string)
print(sorted_string)  # Output: ['e', 'h', 'l', 'l', 'o']

print(ord('A'))  # Output: 65 (Unicode code point for 'A')
print(ord('a'))  # Output: 97 (Unicode code point for 'a')

print(chr(65))  # Output: 'A' (Character for Unicode code point 65)
print(chr(97))  # Output: 'a' (Character for Unicode code point 97)


5
54, <class 'str'>
e
o
['e', 'h', 'l', 'l', 'o']
65
97
A
a

5. String Methods

Python provides a plethora of built-in string methods for various string manipulations. These methods can help you transform, search, and manipulate strings according to your needs.

Common String Methods

# String to be used for demonstration
string = "   Hello, World!   "

# capitalize(): Capitalizes the first character and converts others to lowercase
print(string.capitalize())  # Output: "   hello, world!   "

# title(): Capitalizes the first character of each word
print(string.title())  # Output: "   Hello, World!   "

# upper(): Converts all characters to uppercase
print(string.upper())  # Output: "   HELLO, WORLD!   "

# lower(): Converts all characters to lowercase
print(string.lower())  # Output: "   hello, world!   "

# swapcase(): Swaps the case of each character
print(string.swapcase())  # Output: "   hELLO, wORLD!   "

# count(): Counts the occurrences of a substring
print(string.count("o"))  # Output: 2

# find(): Finds a substring and returns its lowest index
print(string.find("World"))  # Output: 7

# startswith(): Checks if the string starts with a specific prefix
print(string.startswith("Hello"))  # Output: False

# endswith(): Checks if the string ends with a specific suffix
print(string.endswith("World!"))  # Output: True

# index(): Returns the index of a substring (similar to find, but raises ValueError if not found)
print(string.index("o"))  # Output: 5

# isalnum(): Checks if all characters are alphanumeric
print(string.isalnum())  # Output: False

# isalpha(): Checks if all characters are alphabetic
print(string.isalpha())  # Output: False

# isdigit(): Checks if all characters are digits
print(string.isdigit())  # Output: False

# isidentifier(): Checks if the string is a valid identifier
print(string.isidentifier())  # Output: False

# split(): Splits the string based on a delimiter and returns a list
print(string.split(","))  # Output: ['   Hello', ' World!   ']

# join(): Joins a list of words using the string as a separator
words = ["Hello", "World!"]
print(" ".join(words))  # Output: "Hello World!"

# replace(): Replaces a substring with another substring
print(string.replace("Hello", "Hi"))  # Output: "   Hi, World!   "

# strip(): Removes leading and trailing whitespace
print(string.strip())  # Output: "Hello, World!"



   hello, world!   
   Hello, World!   
   HELLO, WORLD!   
   hello, world!   
   hELLO, wORLD!   
3
7
True
True
False
False
False
False
['   Hello', ' World!   ']
Hello World!
   Hi, World!   
Hello, World!

6. String Formatting

String formatting allows you to create dynamic strings by inserting variables or values into a predefined string. This is incredibly useful for creating informative and customizable output.

name = "Alice"
age = 30
message = "My name is {} and I am {} years old.".format(name, age)
print(message)


My name is Alice and I am 30 years old.


name = "Alice"
age = 30
message = f"My name is {name} and I am {age} years old."
print(message)

My name is Alice and I am 30 years old.

7. Escape Sequences

Escape sequences are used to insert special characters into strings. For instance, \n represents a newline character.

escaped_str = "This is a line with\na newline."
print(escaped_str)


This is a line with
a newline.

8. Immutable Nature of Strings

In Python, strings are considered immutable, which means that once a string is created, its contents cannot be modified. You cannot change individual characters or substrings within a string. However, you can create new strings from the original string.

Here are a few reasons why strings are immutable in Python:

  1. Hashing and Dictionary Keys: Strings are often used as keys in dictionaries. Being immutable allows strings to have a consistent hash value, making them suitable for use as keys in hash-based data structures.
  2. Memory Efficiency: Immutable objects, like strings, can be more memory-efficient. Since their content cannot change, the same string can be shared among multiple references without duplicating data.
  3. Safety and Predictability: Immutability ensures that once a string is created, its content remains consistent and predictable throughout the program.
  4. Concurrency: In a multithreaded environment, immutability simplifies concurrent access to the string, as you don’t need to worry about one thread modifying the string while another thread is reading it.

Example of the immutable nature of strings:

string = "hello"
# Attempting to modify a character (which is not allowed)
# This will result in a TypeError: 'str' object does not support item assignment
string[0] = 'H'


TypeError: 'str' object does not support item assignment

If you want to modify a string, you need to create a new string with the desired modifications. For example:

string = "hello"
new_string = string[:1] + 'H' + string[1:]
print(new_string)  # Output: "Hello"


Hello

In this example, a new string new_string is created by combining parts of the original string with the desired modification.

Remember, if you need to make many modifications to a string, especially in a loop or performance-critical code, it’s often more efficient to use other data types like lists and then join them into a string when needed.

Tags:

Leave a Reply

Your email address will not be published. Required fields are marked *