02Everything is an object

In Chapter 1 we made the machine run our code. We shipped a program that printed our two-song playlist and controlled every byte on the way to the screen. But we never stopped to ask what those values actually are. That's this chapter. Here's the plan. We type one honest line — seconds = 200 — and pull it apart into the three separate moves Python really makes. Folded into that one = is the idea the whole language is built on. And we keep coming back to the question most tutorials skip straight past — when you write 200, where does its type live, and where do its behaviours live? The answer is the same for every value you will ever type. Each one is an object: a small parcel carrying its own value, its own type, and its own set of moves. By the end you'll know all six core value types — the three kinds of number, the booleans, that deliberate None, and frozen text versus raw bytes. And you'll be able to hand Python any value and have it tell you what it is, everything it can do, and exactly how many bytes it weighs.

01One line, three moves — everything is an object

Let's start with the smallest line that carries the whole idea. Here's one honest fact about the first track on our playlist — "Blinding Lights" by The Weeknd, 200 seconds long — typed the way you'd type anything. Then we turn around and ask Python what it just made:

seconds = 200              # the length of "Blinding Lights"
title   = "Blinding Lights"

print(type(seconds))     # <class 'int'>
print(type(title))       # <class 'str'>

It reads like a single action — "put 200 into seconds." Watch closely, though. Python actually makes three moves, and their order is the whole secret. Move one, the object. Somewhere in RAM — chapter 0's street of numbered boxes — Python builds an object. It's a small package holding the value 200 and a single pointer to its type, int. That one pointer is the object's whole claim to behaviour. The methods are not copied into the parcel. They live once on the shared int type, and every integer looks them up there on demand. Move two, the name — and move three, the binding. The = creates the name seconds and clips it onto that object in a single stroke. CPython does both as one atomic step (STORE_NAME), so there is no real instant you could catch the tag hanging empty. We split it into two beats only to keep the order visible: the object is built first, and the label is stuck on afterwards. The = never manufactures the value. It only points a label at one that already lives somewhere.

Two sibling rules ride in on the same axiom. Python is case-sensitive. So Title and title are two unrelated names, and asking for one you never bound is an instant error, not a shrug —

title = "Blinding Lights"
print(Title)      # NameError: name 'Title' is not defined

And indentation carries meaning. The blank space at the start of a line is grammar, not decoration, which chapter 5 makes precise. Both rules are downstream of the same discipline: Python takes your words literally and binds them exactly.

So the founding axiom pays off immediately. Because every value is a full object that knows its own type, you never have to declare types up front. You just ask any value what it is. That axiom reaches further than it looks. The type int is itself an object, and its type is type. So is print. So is a whole module. It really is objects most of the way down, bottoming out at type, whose own type is type. For this chapter, though, we only need the everyday values — and here is the map of them.

If every value is an object that knows its own type — what types are there? Python answers the question of "how many is 200" three different ways. Start with the numbers →

02Three kinds of number

You already met the machine's atom in chapter 0 — a switch, a byte, a running time of 200 spelled out in eight lit and unlit boxes. Now Python hands that pile of switches back to you wearing three different faces, and it matters which one you're holding. There is int for whole numbers, float for numbers with a decimal point, and complex for the ones with an imaginary part. They print almost the same, and they add with the same +. Underneath, though, they could hardly be more different. One grows without limit, one lives in a fixed 64-bit box, one carries two coordinates at once. This section is about telling them apart by feel.

you type
seconds = 200
bonus = 45

print(seconds + bonus, seconds - bonus)
print(seconds * 2, seconds / 60)
print(seconds // 60, seconds % 60)
print(2 ** 10, abs(-45))
seconds += 45
print(seconds)

you see
245 155
400 3.3333333333333335
3 20
1024 45
245

seconds = 200            # int     — whole: "Blinding Lights" runs 200 s
minutes = 200 / 60       # float   — 3.3333333333333335, the same song in minutes
z = 3 + 4j               # complex — j is Python's imaginary unit, never i

print((10).bit_length()) # 4   → 10 is 0b1010, four bits — not 32
big = 2 ** 100           # 1267650600228229401496703205376
print(big.bit_length())  # 101 → still exact; a Python int never overflows

length = int("245")      # int() casts the text "245" → the number 245
print(seconds + length)  # 445 → it adds; "200" + "245" would have glued into "200245"

That last pair of lines is the quiet hero. Chapter 1 warned you that input() always hands back text, even when the user typed digits — and text refuses to do arithmetic, it only glues. int("245") is the cure: it casts the characters into an actual number, and suddenly + means add instead of concatenate. Half of all beginner bugs are a number still wearing its text costume.

>>> "200" + "45"
>>> "200" > "1000"
>>> 200 > 1000

'20045'
True
False

you type
text = "245"

print(int(text) + 200)
print(float(text) / 60)
print(str(200) + " seconds")
print(int(4.9), round(4.9))
print(int(True), bool(0), bool("0"))

you see
445
4.083333333333333
200 seconds
4 5
1 False True

Start with the boundless one. In most languages an integer is parked in a fixed box — 32 or 64 switches, no more. A value that outgrows its box overflows: it wraps back to zero like a six-digit odometer rolling from 999999 to 000000. Python's int flatly refuses to wrap. When a number needs more room, the object simply grows. Python bolts on another chunk of bits and keeps counting, as far as your memory allows. That's why 2 ** 100, a number with 31 digits, prints back exactly, not as some rounded approximation. It is also why you can total the raw byte counts of a whole music library and still land on an exact integer. A 4-minute track at 320 kbps already weighs about 9.6 million bytes, and ten thousand of them sail clean past a 32-bit box's four-billion ceiling without ever wrapping to a lie. Slide the control below and watch the difference with your own eyes. The fixed 8-bit box on top can only ever hold 0–255, so push past 255 and it wraps. The Python int underneath just grows another box.

That bit_length() lands us on a fact worth burning in, because a widely-copied note online gets it wrong: (10).bit_length() is 4, not 32. Ten in binary is 1010 — four significant bits — and Python keeps only those four. There is no hidden 32-bit box padding the number out with leading zeros. The lower row in the figure above literally draws four boxes for ten and stops. bit_length() is Python telling you the smallest number of switches this value needs. That's why 2 ** 100 reports 101 and not some round machine width.

Why can't the float just be exact too, the way the int is? Because it made the opposite bargain. A float is always the same 64 switches, no matter what number sits in it — 3.14, or 3×10³⁰⁰, or one tenth. That fixed size is the point. Fixed-size means the arithmetic is wired straight into your CPU, so floats are blisteringly fast and never grow. The price is precision. Sixty-four bits can only name about 15–17 significant decimal digits and a fixed menu of fractions. So any value off that menu — like 0.1 — gets rounded to the closest one on it.

you type
minutes = 200 / 60
mp3_bytes = 9600000

print(f"{minutes:.2f}")
print(f"[{minutes:>10.2f}]")
print(f"[{'Titanium':<12}]")
print(f"{mp3_bytes:,}")
print(f"{7:02d}:{5:02d}")
print(f"{0.7315:.1%}")

you see
3.33
[      3.33]
[Titanium    ]
9,600,000
07:05
73.2%

# set_stats.py -- turn raw numbers into a table you would actually ship

one_title, one_sec = "Blinding Lights", 200
two_title, two_sec = "Titanium", 245
kbps = 320

total = one_sec + two_sec
one_bytes = one_sec * kbps * 1000 // 8
two_bytes = two_sec * kbps * 1000 // 8

print(f"{'TRACK':<18}{'SEC':>5}{'MIN':>8}{'BYTES':>14}{'SHARE':>8}")
print("-" * 53)
print(f"{one_title:<18}{one_sec:>5}{one_sec/60:>8.2f}{one_bytes:>14,}{one_sec/total:>8.1%}")
print(f"{two_title:<18}{two_sec:>5}{two_sec/60:>8.2f}{two_bytes:>14,}{two_sec/total:>8.1%}")
print("-" * 53)
print(f"{'TOTAL':<18}{total:>5}{total/60:>8.2f}{one_bytes+two_bytes:>14,}{1.0:>8.1%}")
print()
print(f"raw float, unformatted: {one_sec/60}")

TRACK               SEC     MIN         BYTES   SHARE
-----------------------------------------------------
Blinding Lights     200    3.33     8,000,000   44.9%
Titanium            245    4.08     9,800,000   55.1%
-----------------------------------------------------
TOTAL               445    7.42    17,800,000  100.0%

raw float, unformatted: 3.3333333333333335

The third face, complex, answers a need the first two can't. Some quantities are irreducibly two-dimensional and have to travel as a single value: the phasor of an AC voltage (a magnitude and a phase at once), one bin of an audio FFT (a real part and an imaginary part), or simply a point on the plane. You may go years without reaching for it. But when the problem has two axes, one number must carry both. Write 3 + 4j and you get exactly that: a single value holding a real coordinate and an imaginary one. Python uses j for the imaginary unit, not the mathematician's i (electrical engineers do the same, to avoid clashing with i for current). Ask a complex number about itself and it answers. (3 + 4j).real is 3.0, .imag is 4.0, and abs(3 + 4j) is 5.0 — the length of the arrow to that point, your old friend the 3-4-5 triangle.

seconds = 245

print(f"{seconds // 60}:{seconds % 60:02d}")
print(f"{seconds // 60:02d}:{seconds % 60:02d}")

total = 200 + 245 + 203
print(f"{total // 60}:{total % 60:02d}")

# 4:05
# 04:05
# 10:48

Three kinds of number, and yet Python is hiding a fourth in plain sight — one wearing the costume of a word. True is quietly worth 1, False is worth 0, and lurking beside them is a deliberate nothing that is not zero at all →

03True, False, and a deliberate nothing

Two sections back you watched whole numbers grow out of switches. Now meet the smallest number type of all — so small it holds exactly two values. Python calls it bool, and its two values are True and False, each spelled with a leading capital, always. That capital is not decoration. Python is case-sensitive, so true and TRUE are not booleans. They are just names the language has never heard of, and reaching for one is an instant error. A bool is a single yes-or-no: the software echo of the one bit you met at the very bottom of the machine.

Here is the twist that catches everyone. A bool is not its own separate kind of value — it is a flavour of integer. In Python's family tree, bool is a subtype of int. True is genuinely equal to 1 and False to 0. They occupy the same 28 bytes an ordinary small integer does, and they will do arithmetic without a word of complaint. True + True is 2. Not a party trick, not a coincidence: a boolean simply is a number, printed in friendlier ink.

# a bool is a flavour of int — same value, same 28 bytes
print(True == 1)                # True
print(isinstance(True, int))    # True  — bool IS a kind of int
print(True + True)              # 2     (yes, really)
print(issubclass(bool, int))  # True

# equal in value is not the same as being the same object
one = 1
print(True is one)             # False — == compares value, is compares identity

next_track = None              # nothing queued after "Titanium"
print(type(next_track))        # <class 'NoneType'>

So a bool and an int are cut from the same cloth. But Python still draws a clean line around the two of them and a third, lonelier value. The map below is worth a slow look: bool nested inside int, and off on its own, a type with a single inhabitant.

Numbers and booleans are not the only things Python can weigh on this scale. Pour any value through bool() and it comes out as exactly one of those two. That squeeze is called truthiness, and in chapter 5 every if and while you write will lean on it. The rule is blunt and worth burning in. A value is falsy when it is empty, zero, or nothing — 0, 0.0, the empty string "", the empty list [], the empty dict {}, and None. It is truthy in every other case. Drag through the zoo below and watch each value fall to one side.

Which leaves the strangest value in the language: None. It is Python's deliberate nothing — not zero, not the empty string, but a real object whose whole job is to mean "no value here, and that is on purpose." Our playlist uses it honestly. next_track = None says the queue after "Titanium" is empty, a genuinely different fact from a track whose title happens to be "". Because None carries no data, no two Nones could ever differ. So Python builds exactly one at start-up and hands that same object to everyone who asks — a pattern called a singleton. It is a bare object header, 16 bytes with nothing inside, smaller even than the integer 0 (which needs 28). Ask its type and Python answers <class 'NoneType'>: a type with exactly one possible value.

you type
print(True + True, int(False))
print(200 > 210, "Titanium" == "titanium")
print(bool(""), bool("0"), bool([]), bool(0.0), bool(None))
next_track = None
print(next_track is None, bool(next_track))

you see
2 0
False False
False True False False False
True False

Numbers, booleans, a deliberate nothing — all tidy, countable, and cheap. But a playlist is mostly text, and Python's text is carved in stone: you may read every character, yet never reshape one in place. Next we hold a string up to the light — frozen letters above, raw bytes beneath →

04Text is frozen; bytes are raw

A number knows nothing about itself. Back in chapter 0 you watched "Blinding Lights" laid across fifteen boxes in RAM, its first letter B stored not as a shape but as the bare number 66 — with a promise to say later which code, and why. This is later. str is Python's text type, and the refinement is one sentence: a string is a sequence of Unicode code points. Unicode is the single table the whole planet agreed on. Every character that has ever been written — every Latin letter, every kanji, every emoji — gets one permanent number called its code point. B is 66, é is 233, the note 🎵 is 127,925. A string is just those numbers stood in a row, each still wearing its agreed-upon meaning.

And a string is frozen. Once Python builds one, nothing edits it in place — not you, not a method, not a single character of it. Every method that looks like it changes text quietly mints a brand-new string and hands that back, leaving the original untouched. That one rule is that str is immutable. It shapes half of what you'll do with text, so hold it close.

you type
t = "Blinding Lights"

print(t[0], t[-1])
print(t[0:8])
print(t[9:])
print(t[:8], t[-6:])
print(t[::2])
print(t[::-1])
print(len(t))

you see
B s
Blinding
Lights
Blinding Lights
Bidn ihs
sthgiL gnidnilB
15

That bottom row is the other sequence type in this section. bytes is a row of raw values 0–255 with no meaning attached at all — the parcels that files on disk, packets on a network, and every MP3 of the song are actually made of. str lives only inside Python. The moment text has to leave — hit a disk, cross a socket — it must be encoded into bytes. "Blinding".encode() gives b'Blinding'. Reach into bytes with an index and you get a plain int back: b'Blinding'[0] is 66, not "B". Indexing a str, by contrast, hands you a one-character string. Two sequences, two temperaments.

you type
raw = "  blinding lights  "

print(raw.strip())
print(raw.strip().upper())
print(raw.strip().title(), raw.strip().lower())
print("The Weeknd - Blinding Lights".split(" - "))
print(" / ".join(["Blinding Lights", "Titanium"]))
print("Blinding Lights".replace("Lights", "Dark"))
print("Blinding Lights".find("Lights"), "Blinding Lights".find("z"))
print("Blinding Lights".startswith("Blind"), "Blinding Lights".endswith("hts"))

you see
blinding lights
BLINDING LIGHTS
Blinding Lights blinding lights
['The Weeknd', 'Blinding Lights']
Blinding Lights / Titanium
Blinding Dark
9 -1
True True

But the tidy one-number-per-letter picture in that figure only holds for plain ASCII. The moment a real playlist carries a name like Beyoncé, that accented é pushes past code point 127 and no longer fits in a single byte. The encoder spreads it across two, three, even four. Drag through a few characters below and watch one code point balloon into a parcel of raw bytes.

artist = "The Weeknd"
title = "Blinding Lights"

a = artist[0] + artist[artist.find(" ") + 1]
t = title[0] + title[title.find(" ") + 1]
print(a.upper(), t.upper())

parts = title.split()            # ['Blinding', 'Lights']
print((parts[0][0] + parts[1][0]).upper())

print(f"{a.upper()} - {t.upper()}")

# TW BL
# BL
# TW - BL

Now watch immutability in the open. Every string method returns a new string, and the one you called it on is never touched. find reports an index, or -1 for "not here" rather than raising. And a direct edit — track[0] = "B" — is simply forbidden.

# a str is a sequence of code points — and it never changes in place
track = "blinding lights"

print(track.title())                  # Blinding Lights   — a NEW string
print(track.find("titanium"))         # -1   — "not found" is -1, never a crash
print(track.replace("lights", "dark"))  # blinding dark    — also a NEW string
print(track)                          # blinding lights  — the original never moved

wire = track.encode()                 # b'blinding lights' — packed for the outside world
print(wire[0])                       # 98   — indexing bytes returns a number, not "b"
print(wire.decode())                  # blinding lights  — bytes read back into text

# track[0] = "B"    →  TypeError: 'str' object does not support item assignment

# song_surgery.py -- one messy line of text, taken apart and rebuilt

raw = "   the weeknd - blinding lights   "
clean = raw.strip()

print(f"[{raw}]")
print(f"[{clean}]")

cut = clean.find(" - ")
artist = clean[:cut]
title = clean[cut + 3:]
print(cut, "|", artist, "|", title)

parts = clean.split(" - ")
print(parts)
print(parts[0].title(), "|", parts[1].title())

print(" - ".join([title.title(), artist.title()]))
print(clean.replace(" - ", " by ").title())
print(title.title()[::-1])
print(raw)

[   the weeknd - blinding lights   ]
[the weeknd - blinding lights]
10 | the weeknd | blinding lights
['the weeknd', 'blinding lights']
The Weeknd | Blinding Lights
Blinding Lights - The Weeknd
The Weeknd By Blinding Lights
sthgiL gnidnilB
   the weeknd - blinding lights   

Seven types now, each frozen or fluid, each priced differently. So how do you walk up to a value you've never met — ask what it is, whether two of them are truly the same, and exactly what it weighs? →

messy = "   tHe WeEknd  -  BLINDING lights   "

clean = messy.strip().replace("  ", " ").title()

print(f"[{clean}]")
print(f"[{messy}]")
print(len(messy), len(clean))

# [The Weeknd - Blinding Lights]
# [   tHe WeEknd  -  BLINDING lights   ]
# 36 28

05Interrogate any value — and weigh it

Because every value in Python is an object — a little parcel that carries its own type and its own behaviour — you never have to guess what you're holding. You can ask it. Python hands you a small interrogation kit that works on anything: a number, a string, a song length, a value you've never seen before. Four questions and a scale. type(x) asks "what are you?" isinstance(x, int) asks "are you this kind of thing?" dir(x) asks "what can you do?" id(x) asks "where do you live?" And sys.getsizeof(x) puts the object on a scale and reads off its weight in bytes.

Point the kit at the length of "Blinding Lights" — the number 200 — and it answers int, True, an address, 28 bytes. Point it at the title string and every answer changes, because the object is different. The value isn't looking anything up in a manual. It is the manual. That's the whole payoff of "everything is an object": the answers travel inside the thing you're asking about.

you type
import sys

title = "Blinding Lights"

print(type(title))
print(type(title).__name__)
print(isinstance(title, str), isinstance(200, str))
print(type(True) == int, isinstance(True, int))
print(len(dir(title)), len(dir(int)))
print(sys.getsizeof(title), sys.getsizeof(200), sys.getsizeof(None))

you see
<class 'str'>
str
True False
False True
81 74
56 28 16

Look closely at two of those questions and you'll spot Python's two shapes for "run some code on a value." len(title) is a function: a free-standing tool, and the object goes in as an argument. title.upper() is a method: behaviour that lives inside the str type itself, reached through the object with a dot. Same idea — code acting on a value — but a different address for the tool. Functions you hand the value to. Methods the value carries with it.

Traceback (most recent call last):
  File "now_playing.py", line 6, in <module>
    print(seconds.upper())
          ^^^^^^^^^^^^^
AttributeError: 'int' object has no attribute 'upper'

set_length.py:5: SyntaxWarning: 'int' object is not callable; perhaps you missed a comma?
  both_twice = 2(blinding + titanium)
Traceback (most recent call last):
  File "set_length.py", line 5, in <module>
    both_twice = 2(blinding + titanium)
                 ^^^^^^^^^^^^^^^^^^^^^^
TypeError: 'int' object is not callable

Traceback (most recent call last):
  File "save_titles.py", line 4, in <module>
    raw = artist.encode("ascii")
          ^^^^^^^^^^^^^^^^^^^^^^
UnicodeEncodeError: 'ascii' codec can't encode character '\xe9' in position 6: ordinal not in range(128)

Here's the whole kit fired at one string. Nothing to install, nothing to configure — just questions and answers:

import sys
title = "Blinding Lights"

print(type(title))              # <class 'str'>   — "what are you?"
print(isinstance(title, str))   # True            — "are you this kind?"
print(isinstance(True, int))    # True            — a bool IS an int underneath
print(len(title))               # 15              — FUNCTION: the value goes in
print(title.upper())          # BLINDING LIGHTS — METHOD: reached with a dot
print(len(dir(title)))          # 81              — every name this str carries
print(id(title))                # 140399482229104 (varies) — where it lives
print(sys.getsizeof(title))     # 56              — its weight, in bytes
print(sys.getsizeof(200))       # 28              — one small int

That dir(title) is worth a pause. It spills out 81 names the string carries — 47 of them public methods like .upper(), .find(), .split(), the rest the dunder machinery we'll meet later. You never memorise a string's abilities. You ask it for the list. And id(title) returns a plain integer that is, in CPython, the object's actual address in RAM — the house number from chapter 0, made visible. (That address-equals-id fact is a CPython promise, not a Python one: the language guarantees only that id is a unique, unchanging integer for as long as the object lives. Chapter 3 turns it into a superpower.)

Now the scale. Every literal from this chapter has a price in bytes. Step through them and watch the object announce its type, place itself in Python's family tree, and tip the scale:

You now have the tools to weigh and identify any object. But one thread from earlier is impossible to ignore: the value 200 was built first, and the name only points at its address. So what happens with b = seconds? Two names, one object — and id() can prove it. Chapter 3 follows the arrows into names & memory. →

# word_count.py -- Ajai's 99-Projects "Word Count", rebuilt with chapter 2 tools
# the original opened a .txt file; we inline the text so this runs anywhere

text = """The Weeknd - Blinding Lights - 200
David Guetta - Titanium - 245
Dua Lipa - Levitating - 203"""

words = text.split()
lines = text.split("\n")
tight = text.replace(" ", "").replace("\n", "")

print("WORD COUNT  ---  set list")
print("=" * 44)
print(f"{'characters (raw)':<28}{len(text):>16,}")
print(f"{'characters (no whitespace)':<28}{len(tight):>16,}")
print(f"{'words':<28}{len(words):>16,}")
print(f"{'lines':<28}{len(lines):>16,}")
print(f"{'dash separators':<28}{text.count(' - '):>16,}")
print("-" * 44)
print(f"{'average word length':<28}{len(tight)/len(words):>16.2f}")
print(f"{'whitespace share of file':<28}{(len(text)-len(tight))/len(text):>16.1%}")
print(f"{'first word':<28}{words[0]:>16}")
print(f"{'last word':<28}{words[-1]:>16}")
print(f"{'bytes on disk (utf-8)':<28}{len(text.encode()):>16,}")

WORD COUNT  ---  set list
============================================
characters (raw)                          92
characters (no whitespace)                74
words                                     19
lines                                      3
dash separators                            6
--------------------------------------------
average word length                     3.89
whitespace share of file               19.6%
first word                               The
last word                                203
bytes on disk (utf-8)                     92