Python for Beginners — Part 3: Strings & Booleans

Part 3 of a beginner-friendly series on learning Python from scratch.

In Part 2, we learned how variables hold data and how Python figures out types automatically. Now we're going to get comfortable with the two types you'll probably use more than any others: strings (text) and booleans (true/false logic).

What is a String?

A string is a sequence of characters — letters, numbers, spaces, punctuation — anything you can type. In Python, strings are wrapped in quotes (single or double):

name = "Ramesh"
greeting = 'Hello, World!'
address = "123 Main Street, Chennai"

Single and double quotes work identically — use whichever feels natural. The only rule is: start and end with the same type.

msg = "It's a beautiful day"    # fine — single quote inside double quotes
msg = 'It's a beautiful day'    # ERROR — the middle quote closes the string early
msg = 'It\'s a beautiful day'   # fine — backslash escapes the quote

Multi-line strings

For longer text, use triple quotes (three single or double quotes in a row):

poem = """
Roses are red,
Violets are blue,
Python is awesome,
And you can code too.
"""

This is also handy for comments spanning multiple lines.

String Operations

Concatenation — joining strings

Use + to join strings together:

first_name = "Ramesh"
last_name = "Kumar"
full_name = first_name + " " + last_name
print(full_name)  # Ramesh Kumar

Repetition — repeating strings

Use * to repeat a string a certain number of times:

print("Ha" * 3)    # HaHaHa
print("-" * 20)    # --------------------

String length

Use len() to count how many characters are in a string:

text = "Python"
print(len(text))   # 6

String Indexing & Slicing

Strings are sequences, which means each character has a position. Python uses zero-based indexing — the first character is at position 0.

word = "Python"
print(word[0])    # P
print(word[1])    # y
print(word[5])    # n
print(word[-1])   # n (the last character)
print(word[-2])   # o (second from the end)

Negative indices count backward from the end.

Slicing — extracting parts of a string

Use the slice syntax [start:end] to extract a substring. Remember: end is exclusive (not included):

word = "Python"
print(word[0:2])   # Py (positions 0 and 1, not 2)
print(word[2:6])   # thon (positions 2, 3, 4, 5)
print(word[:3])    # Pyt (from start up to position 3)
print(word[3:])    # hon (from position 3 to the end)
print(word[::2])   # Pto (every 2nd character)

If you're new to slicing, write out the positions on paper once or twice — it clicks quickly.

String Methods

Strings come with dozens of built-in methods — functions that operate on the string itself. Here are the ones you'll use constantly:

text = "hello world"

# Change case
print(text.upper())            # HELLO WORLD
print(text.capitalize())       # Hello world
print(text.title())            # Hello World

# Find and replace
print(text.find("world"))      # 6 (position where "world" starts)
print(text.replace("world", "Python"))  # hello Python

# Strip whitespace
messy = "  hello  "
print(messy.strip())           # hello (removes leading/trailing spaces)
print(messy.lstrip())          # hello   (removes from left only)
print(messy.rstrip())          #   hello (removes from right only)

# Check properties
print(text.startswith("hello"))     # True
print(text.endswith("world"))       # True
print(text.isdigit())              # False
print(text.isalpha())              # False (has a space)
print("123".isdigit())             # True

# Split and join
words = text.split()               # ["hello", "world"]
print(" ".join(words))             # hello world

Pro tip: When you type a variable name followed by a dot in most code editors, you'll get an autocomplete menu showing all available methods. This is invaluable — you don't need to memorize everything, just know they exist.

String Formatting

As your programs grow, you'll often need to insert variable values into strings. There are several ways to do this:

f-strings (Python 3.6+, recommended)

The modern, readable way:

name = "Ramesh"
age = 25
city = "Chennai"

message = f"My name is {name}, I'm {age} years old, and I live in {city}."
print(message)  # My name is Ramesh, I'm 25 years old, and I live in Chennai.

You can even do simple expressions inside the braces:

x = 10
y = 20
print(f"The sum of {x} and {y} is {x + y}.")  # The sum of 10 and 20 is 30.

.format() method (older, still valid)

message = "My name is {}, I'm {} years old.".format(name, age)
print(message)

String concatenation (not recommended for complex cases)

message = "My name is " + name + ", I'm " + str(age) + " years old."

This works, but gets messy fast. f-strings are cleaner and faster.

Booleans

A boolean is a value that's either True or False. It's the simplest data type in Python, but also one of the most important because booleans drive all the decision-making in your programs.

is_raining = True
is_sunny = False

Boolean values are returned by comparison operators — expressions that compare two values:

x = 10
y = 20

print(x == y)    # False (equal to)
print(x != y)    # True (not equal to)
print(x < y)     # True (less than)
print(x > y)     # False (greater than)
print(x <= y)    # True (less than or equal)
print(x >= y)    # False (greater than or equal)

You can also compare strings:

print("apple" == "apple")       # True
print("apple" < "banana")       # True (alphabetical order)
print("apple" != "banana")      # True

Logical Operators

With boolean values, you can combine multiple conditions using logical operators:

and — both must be True

age = 25
has_license = True

can_drive = (age >= 18) and (has_license == True)
print(can_drive)  # True

or — at least one must be True

is_weekend = True
is_holiday = False

no_work = is_weekend or is_holiday
print(no_work)  # True

not — reverses the boolean

is_raining = True
print(not is_raining)   # False
print(not False)        # True

These operators are essential for building if statements, which we'll cover in depth in Part 4.

Why This Matters

Strings and booleans are the workhorses of Python. Nearly every program you write will manipulate text (logs, user messages, file contents, API responses) and make decisions based on true/false logic. Getting comfortable with string slicing, methods, and formatting early will save you hours of debugging later. And understanding how boolean expressions work is the foundation for all the control flow we're about to cover.

What's Next

In Part 4, we'll dive into operators and control flow — how to build if/elif/else statements, use while and for loops, and make your programs actually do things based on conditions.

---

This is Part 3 of an 8-part beginner Python series. Catch up on Part 1: Getting Started & Syntax and Part 2: Variables, Data Types & Numbers, or continue to Part 4 once it's live.

---

Related Search Terms: Python string tutorial, Python boolean tutorial, string slicing Python, string methods examples, how to format strings Python, if statements Python, logical operators Python, Python for beginners

Internal Links: Part 1: Getting Started & Syntax | Part 2: Variables, Data Types & Numbers | Part 4: Operators & Control Flow (coming soon)