How to Check If a String Is Whitespace in Python

Introduction

In this lab, you will learn how to check if a string consists entirely of whitespace characters in Python. The lab begins by defining common whitespace characters such as space, tab, newline, carriage return, vertical tab, and form feed. You will then create a Python script to demonstrate these characters and their effects on text formatting.

The lab will guide you through using the isspace() method to determine if a string contains only whitespace. Finally, it will differentiate between strings containing whitespace and empty strings, highlighting the importance of understanding these distinctions in Python programming.

Define Whitespace Characters

In this step, you will learn about whitespace characters in Python. Whitespace characters are characters that represent empty space. They are important in programming because they affect how code is interpreted and displayed. Understanding whitespace is crucial for writing clean and readable Python code.

Common whitespace characters include:

Space (``): The most common whitespace character, used to separate words and statements.
Tab (\t): Used for indentation, typically representing four spaces.
Newline (\n): Used to indicate the end of a line.
Carriage Return (\r): Used in older systems to return the cursor to the beginning of the line.
Vertical Tab (\v): Less commonly used, but still a whitespace character.
Form Feed (\f): Used to advance to the next page in printing.

Let's create a Python script to demonstrate these characters.

Open the VS Code editor in the LabEx environment.
Create a new file named whitespace_demo.py in the ~/project directory.
```
touch ~/project/whitespace_demo.py
```

Open the whitespace_demo.py file in the editor and add the following content:

## Demonstrating whitespace characters

space_char = " "
tab_char = "\t"
newline_char = "\n"
carriage_return_char = "\r"
vertical_tab_char = "\v"
form_feed_char = "\f"

print("This", space_char, "is", space_char, "separated", space_char, "by", space_char, "spaces.")
print("This\tis\tseparated\tby\ttabs.")
print("This" + newline_char + "is" + newline_char + "on" + newline_char + "multiple" + newline_char + "lines.")
print("This" + carriage_return_char + "will overwrite the beginning of the line.")
print("Vertical" + vertical_tab_char + "Tab")
print("Form" + form_feed_char + "Feed")

This script defines variables for each whitespace character and then uses them in print() statements to demonstrate their effects.

Run the script using the python command:
```
python ~/project/whitespace_demo.py
```
You should see output similar to the following:
```
This   is   separated   by   spaces.
This    is      separated       by      tabs.
This
is
on
multiple
lines.
 will overwrite the beginning of the line.
Vertical Tab
Form Feed
```
Notice how each whitespace character affects the formatting of the output. The newline character creates line breaks, and the tab character creates horizontal spacing. The carriage return overwrites the beginning of the line. The vertical tab and form feed characters might not be visible depending on your terminal.

Use isspace() Method

In this step, you will learn how to use the isspace() method in Python to check if a string consists of only whitespace characters. This method is very useful for validating user input or cleaning up data.

The isspace() method is a built-in string method that returns True if all characters in the string are whitespace characters (space, tab, newline, etc.) and there is at least one character. Otherwise, it returns False.

Let's create a Python script to demonstrate the isspace() method.

Open the VS Code editor in the LabEx environment.
Create a new file named isspace_demo.py in the ~/project directory.
```
touch ~/project/isspace_demo.py
```

Open the isspace_demo.py file in the editor and add the following content:

## Demonstrating the isspace() method

string1 = "   "  ## Contains only spaces
string2 = "\t\n"  ## Contains tabs and newlines
string3 = "  abc  "  ## Contains spaces and letters
string4 = ""  ## Empty string
string5 = "123" ## Contains numbers

print(f"'{string1}'.isspace(): {string1.isspace()}")
print(f"'{string2}'.isspace(): {string2.isspace()}")
print(f"'{string3}'.isspace(): {string3.isspace()}")
print(f"'{string4}'.isspace(): {string4.isspace()}")
print(f"'{string5}'.isspace(): {string5.isspace()}")

This script defines several strings with different combinations of whitespace and non-whitespace characters. It then uses the isspace() method to check if each string consists only of whitespace characters.

Run the script using the python command:
```
python ~/project/isspace_demo.py
```
You should see output similar to the following:
```
'   '.isspace(): True
'
'.isspace(): True
'  abc  '.isspace(): False
''.isspace(): False
'123'.isspace(): False
```
As you can see, isspace() returns True only for strings that contain only whitespace characters and are not empty.

Differentiate from Empty Strings

In this step, you will learn to differentiate between strings containing only whitespace and empty strings in Python. It's important to understand the difference because isspace() behaves differently for empty strings.

As you learned in the previous step, the isspace() method returns True if all characters in a string are whitespace characters and the string is not empty. For an empty string (a string with no characters), isspace() returns False.

Let's modify the isspace_demo.py script from the previous step to emphasize this difference.

Open the isspace_demo.py file in the VS Code editor in the ~/project directory.

Modify the script to include a more explicit check for empty strings:

## Demonstrating the isspace() method and empty strings

string1 = "   "  ## Contains only spaces
string2 = ""  ## Empty string

print(f"'{string1}'.isspace(): {string1.isspace()}")
print(f"'{string2}'.isspace(): {string2.isspace()}")

if string2:
    print("string2 is not empty")
else:
    print("string2 is empty")

if string1.isspace():
    print("string1 contains only whitespace")
else:
    print("string1 does not contain only whitespace")

This script now includes an if statement to check if string2 is empty. It also checks if string1 contains only whitespace characters.

Run the script using the python command:
```
python ~/project/isspace_demo.py
```
You should see output similar to the following:
```
'   '.isspace(): True
''.isspace(): False
string2 is empty
string1 contains only whitespace
```
This output clearly shows that isspace() returns False for an empty string, and the if statement correctly identifies string2 as an empty string.

Summary

In this lab, you learned about whitespace characters in Python, which are characters that represent empty space and affect code interpretation and display. The lab covered common whitespace characters such as space, tab, newline, carriage return, vertical tab, and form feed.

You created a Python script named whitespace_demo.py to demonstrate these characters by defining variables for each and using them in print() statements to illustrate their effects on text formatting and output.