String Indexing & Slicing

By the end of this lesson you can:

• Pull a single letter out of a string with word[0], word[3] or word[-1], and count letters with len(word).
• Slice out substrings with word[1:4], word[:3] and word[3:] — and explain why the stop number is excluded.
• Use the reverse-slice word[::-1] to spell a word backwards, and use it to spot palindromes like "malam" and "katak".

Last lesson we cleaned and replaced whole strings. Today we peek inside one. Remember from L1-15 how a list lets you reach in with my_list[0]? Strings do the exact same thing.

Quick predict-the-output puzzle. What does Python print?

word = "MALAYSIA"

print(word[0])
print(word[-1])
print(word[1:4])
print(len(word))

M
A
ALA
8

Each letter has an address

Picture the word "MALAM" as a row of pigeon-holes. Each letter sits in a numbered box, starting at 0:

#  index:   0   1   2   3   4
#  letter:  M   A   L   A   M
#  neg:    -5  -4  -3  -2  -1

The same trick we used for lists in PY-L1-15 — including negative indices that count from the end — works for strings:

word = "MALAM"

print(word[0])    # M  (first letter)
print(word[2])    # L  (third letter)
print(word[-1])   # M  (last letter)
print(word[-2])   # A  (second-from-last)

Index 0 is letter one — get used to it

This is the bug that every beginner writes at least once: thinking word[1] gives the first letter. It doesn't. The boxes are numbered like floors in some buildings — there's a Floor 0 before Floor 1. Index 0 = first letter.

Indexing too far · IndexError

Ask for a letter that doesn't exist and Python complains:

word = "MALAM"   # length 5, valid indices 0..4
print(word[5])

IndexError: string index out of range

Why? len("MALAM") is 5, but valid indices are 0, 1, 2, 3, 4. The last valid index is always len(word) - 1. Or just use word[-1] and never worry about it.

Slicing · grab a chunk in one go

A slice uses two numbers separated by a colon: word[start:stop]. It returns a new string containing the letters from start up to but not including stop.

word = "MALAYSIA"
#        01234567

print(word[0:4])   # MALA   (letters 0,1,2,3)
print(word[4:8])   # YSIA   (letters 4,5,6,7)
print(word[1:4])   # ALA    (letters 1,2,3)

Why exclude the stop? It means word[0:4] gives you exactly 4 letters — 4 - 0. Always works out clean. You can also drop one end:

name = "Hafiz"

print(name[:3])    # Haf   (from the start, up to index 3)
print(name[2:])    # fiz   (from index 2, all the way to the end)
print(name[:])     # Hafiz (a full copy)

The famous reverse slice

A slice has a secret third number — a step. word[::2] walks two letters at a time, and the iconic word[::-1] walks backwards, spelling the whole string in reverse:

word = "katak"
print(word[::-1])
# → katak

word = "Hafiz"
print(word[::-1])
# → zifaH

This one-liner is the standard Python party trick. It also gives us the easiest palindrome check ever written:

word = "malam"
if word == word[::-1]:
    print("Palindrome!")
else:
    print("Nope.")
# → Palindrome!

The job

Priya is building name badges for the KL Robotics Camp. Each badge has two parts: the camper's initials in capitals (P.K.) and an ID tag made from the last four characters of their birth year (e.g. 2013 → 2013). We'll build a tiny script that takes a first name, last name, and a year and prints both lines.

Step 1 · Grab the first letter of each name

first = "Priya"
last = "Kumaran"

print(first[0])   # P
print(last[0])    # K

Step 2 · Build the initials string

Stitch them together with +:

initials = first[0] + "." + last[0] + "."
print(initials)
# → P.K.

Step 3 · Take the last 4 characters of a longer string

The slice [-4:] reads as "from four-from-the-end, all the way to the end":

birth = "20130815"   # full date as text
year_suffix = birth[-4:]   # last four characters
print(year_suffix)
# → 0815

Want the actual year — the first four characters? That's birth[:4]:

year = birth[:4]
print(year)
# → 2013

Step 4 · Assemble the badge

Save as badge.py:

Code

# badge.py — name badge builder

first = "Priya"
last = "Kumaran"
birth = "20130815"

initials = first[0].upper() + "." + last[0].upper() + "."
year = birth[:4]
tag = "KL-" + year + "-" + last[-3:].upper()

print("Initials:", initials)
print("ID tag:", tag)

Output

Initials: P.K.
ID tag: KL-2013-RAN

Notice the cameos from PY-L1-23 — .upper() still works and we're even chaining it onto a single sliced letter. last[-3:] grabs the last three letters of "Kumaran" — that's "ran" — and we shout it.

Three tasks today. Type each, run it, and only peek at the hint if you're truly stuck.

word = "cendol"
print(word[0])
print(word[-1])
print(len(word))

phone = "0123456789"
area = phone[:3]
last4 = phone[-4:]
print("Area:", area)
print("Ending in:", last4)

raw = input("Type a word: ")
word = raw.strip().lower()

if word == word[::-1]:
    print("Palindrome!")
else:
    print("Not a palindrome.")

Strings are sequences of characters with numbered slots. word[0] is the first letter, word[-1] the last, and word[start:stop] grabs a chunk — remembering that stop is always excluded. The negative-step slice word[::-1] spells the whole string backwards, which makes palindrome detection a one-line check. Combine these with the cleaning methods from PY-L1-23 and you can pull apart almost any piece of text.