Learn What an Object Is in Python: Absolute Beginners Tutorial

Python is built on a single foundational idea: everything is an object. Understanding what that means — and how to work with it — is the first step toward writing real Python programs rather than just running scripts line by line.

When you assign a number to a variable, write a string, or build a list, Python represents each of those values as an object in memory. Objects are not just a feature you can choose to use — they are the underlying mechanism that Python uses to represent all data. This tutorial walks through what objects are, what they contain, and how to create your own.

What Is an Object?

An object is a self-contained unit of data and behavior. Every object in Python has three things: an identity (a unique location in memory), a type (which tells Python what kind of object it is), and a value (the actual data it holds).

You can confirm this yourself using Python's built-in functions. id() returns the memory address, type() returns the type, and the variable itself holds the value.

x = 42

print(id(x))      # memory address, e.g. 140234567891234
print(type(x))    # <class 'int'>
print(x)          # 42

The Python documentation describes this directly: every object has an identity, a type, and a value. The identity is fixed once the object is created. The type determines what operations are allowed. The value may or may not be changeable — objects whose value can change are called mutable, and those whose value cannot are called immutable.

"Objects are Python's abstraction for data." — The Python Language Reference, Python Software Foundation

A string like "hello" is immutable — you cannot change the characters in place. A list like [1, 2, 3] is mutable — you can append to it, remove items, or change a value at a given index. Both are objects.

Attributes and Methods

Objects do not just hold data — they also carry behavior. The data stored inside an object is called an attribute. The functions that belong to an object and describe what it can do are called methods. Both are accessed using dot notation.

You have already been using attributes and methods without necessarily calling them by those names. When you call "hello".upper(), you are calling the upper method on a string object. When you check my_list.count(3), you are calling the count method on a list object.

# String object — calling a method
greeting = "hello world"
print(greeting.upper())     # HELLO WORLD
print(greeting.title())     # Hello World

# List object — calling a method and reading a built-in attribute
numbers = [4, 1, 7, 2]
numbers.sort()
print(numbers)              # [1, 2, 4, 7]
print(len(numbers))         # 4 (len is a built-in that reads the object's size)

The distinction between built-in objects (like strings and lists) and objects you define yourself is mostly about who wrote the class. The mechanics are identical. Both kinds have attributes and methods, both are created by calling a class, and both follow the same rules.

Classes: The Blueprint for Objects

Before Python can create an object, it needs a blueprint that describes what the object will contain and what it can do. That blueprint is called a class. A class defines the structure; an object is an instance of that class created from the structure.

The relationship is similar to how a form template works. The template defines which fields exist. Each filled-out copy of the form is a separate instance, with its own specific values in those fields — but they all share the same structure because they came from the same template.

class Dog:
    def __init__(self, name, age):
        self.name = name   # attribute
        self.age = age     # attribute

    def bark(self):        # method
        print(f"{self.name} says: Woof!")

# Create two separate Dog objects from the same class
dog_one = Dog("Biscuit", 3)
dog_two = Dog("Maple", 5)

dog_one.bark()             # Biscuit says: Woof!
dog_two.bark()             # Maple says: Woof!

print(dog_one.age)         # 3
print(dog_two.name)        # Maple

A few things to notice in that example. First, class Dog: defines the blueprint. Second, __init__ is a special method that Python calls automatically when you create a new instance — it sets the initial attribute values. Third, self is a reference to the specific instance being created or used. It appears as the first parameter of every method but you do not pass it in yourself — Python handles that automatically.

# Step 1 — Define the class
class BankAccount:

    # Step 2 — Write __init__
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance

    # Step 3 — Add a method
    def deposit(self, amount):
        self.balance += amount
        print(f"Deposited {amount}. New balance: {self.balance}")

    def get_balance(self):
        return self.balance

# Step 4 — Instantiate
account = BankAccount("Taylor", 500)

# Step 5 — Access attributes and call methods
print(account.owner)         # Taylor
account.deposit(150)         # Deposited 150. New balance: 650
print(account.get_balance()) # 650

Python Learning Summary Points

1. Every value in Python is an object. Integers, strings, lists, functions, and instances of your own classes are all objects with an identity, a type, and a value.
2. A class is a blueprint. An object is an instance of that blueprint. Calling the class with arguments creates a new object in memory.
3. Attributes store an object's data. Methods are functions attached to the object that describe what it can do. Both are accessed with dot notation.
4. __init__ is the initializer method. Python calls it automatically when you create a new instance, setting the object's starting attribute values.
5. self refers to the current instance. It must appear as the first parameter of every method, but Python passes it automatically — you do not supply it when calling the method.

From here, the natural next steps are learning about inheritance (where one class can extend another) and special methods (also called dunder methods) that let your objects respond to built-in operations like +, len(), and print(). But those build directly on what you have learned here: objects have data, objects have behavior, and everything in Python is an object.