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)