Public attributes in Python - Deep Dive

Overview - Public attributes

What is it?

Public attributes are variables that belong to an object and can be accessed or changed from anywhere in the program. They are part of a class and hold data related to an object. Unlike private attributes, public attributes have no special restrictions on access. This means you can read or modify them freely using the object name.

Why it matters

Public attributes make it easy to store and share information inside objects without complicated rules. Without public attributes, programmers would struggle to keep track of data inside objects or would need complex methods to access simple information. This would slow down coding and make programs harder to understand and change.

Where it fits

Before learning public attributes, you should understand what classes and objects are in Python. After mastering public attributes, you can learn about private and protected attributes, which control access more strictly, and about methods that safely manage data inside objects.

Mental Model

Core Idea

Public attributes are like open boxes attached to an object that anyone can look inside or change anytime.

Think of it like...

Imagine a backpack with several pockets. Public attributes are like the outer pockets that anyone can open and put things into or take things out of without asking.

Object
  │
  ├─ Public attribute 1: value
  ├─ Public attribute 2: value
  └─ Public attribute 3: value

Access: object.attribute_name (read or write)

Build-Up - 6 Steps

1

Foundation

What are attributes in Python classes

Concept: Attributes are variables that belong to an object created from a class.

In Python, when you create a class, you can define variables inside it. These variables are called attributes. When you make an object from the class, each object has its own copy of these attributes. Example: class Dog: def __init__(self, name): self.name = name # 'name' is an attribute my_dog = Dog('Buddy') print(my_dog.name) # Output: Buddy

Result

The program prints the name stored in the object's attribute.

Understanding that attributes hold data inside objects is the first step to organizing information in programs.

2

Foundation

Accessing attributes directly

Concept: You can get or change attribute values directly using the object and dot notation.

Once an object has attributes, you can read or update them by writing object.attribute_name. Example: my_dog.name = 'Max' # Change the name attribute print(my_dog.name) # Output: Max

Result

The attribute value changes and prints the new value.

Knowing you can directly access attributes makes it easy to work with object data without extra code.

3

Intermediate

Public attributes have no access restrictions

🤔Before reading on: do you think public attributes can be hidden or protected from outside access? Commit to your answer.

Concept: Public attributes are accessible from anywhere in the program without restrictions.

In Python, attributes are public by default. This means you can read or write them from outside the class freely. Example: class Car: def __init__(self, color): self.color = color # public attribute my_car = Car('red') print(my_car.color) # Output: red my_car.color = 'blue' print(my_car.color) # Output: blue

Result

The attribute value is accessed and changed without any error.

Understanding that public attributes have no barriers helps you decide when to use them for simple data storage.

4

Intermediate

Why use public attributes simply

🤔Before reading on: do you think using public attributes everywhere is always safe and good? Commit to your answer.

Concept: Public attributes are simple but can lead to problems if used without care, especially in big programs.

Using public attributes is easy, but if many parts of a program change them freely, it can cause bugs or unexpected behavior. For example, changing an attribute to an invalid value might break the program. Example: my_car.color = 123 # This makes no sense but Python allows it print(my_car.color) # Output: 123

Result

The attribute holds an invalid value, which might cause errors later.

Knowing the risks of public attributes encourages you to use them wisely or add checks when needed.

5

Advanced

Combining public attributes with methods

🤔Before reading on: do you think methods can help control public attribute changes? Commit to your answer.

Concept: Methods can be used to safely update or read public attributes, adding control without hiding them completely.

You can write methods that check or modify public attributes to keep data valid. Example: class Person: def __init__(self, age): self.age = age # public attribute def set_age(self, new_age): if new_age >= 0: self.age = new_age else: print('Age cannot be negative') p = Person(30) p.set_age(-5) # Prints warning, does not change age print(p.age) # Output: 30

Result

The age attribute remains valid because the method prevents bad changes.

Understanding how methods can protect public attributes helps balance simplicity and safety.

6

Expert

Public attributes and Python's naming conventions

🤔Before reading on: do you think Python enforces attribute privacy strictly? Commit to your answer.

Concept: Python uses naming conventions to signal attribute privacy, but public attributes are accessible regardless of naming.

Python does not enforce strict privacy. Attributes starting with a single underscore (_) are meant to be 'protected' by convention but are still accessible. Double underscores (__) trigger name mangling but can still be accessed if needed. Example: class Example: def __init__(self): self.public = 1 self._protected = 2 self.__private = 3 obj = Example() print(obj.public) # 1 print(obj._protected) # 2 (should be treated as internal) # print(obj.__private) # Error print(obj._Example__private) # 3 (name mangled access)

Result

Public attributes are fully accessible; naming hints do not block access.

Knowing Python's flexible privacy model clarifies that public attributes are truly open and that privacy is by agreement, not enforcement.

Under the Hood

In Python, when you create an object, its attributes are stored in a dictionary called __dict__. Public attributes are keys in this dictionary pointing to their values. Accessing or changing an attribute uses this dictionary behind the scenes. Since there are no restrictions, any code with the object reference can read or write these keys freely.

Why designed this way?

Python was designed to be simple and flexible. Instead of strict access controls like some languages, it trusts programmers to follow conventions. This design choice makes Python easy to learn and fast to write, while still allowing advanced users to enforce privacy if needed.

Object instance
  ├─ __dict__ (attribute storage)
  │    ├─ 'attribute_name': value
  │    ├─ 'another_attr': value
  │    └─ ...
  └─ Access via object.attribute_name
       ↓
  Lookup in __dict__ returns or sets value

Myth Busters - 3 Common Misconceptions

Quick: Do public attributes prevent outside code from changing their values? Commit yes or no.

Common Belief: Public attributes are protected and cannot be changed from outside the class.

Reality: Public attributes can be freely read and modified from anywhere in the program.

Why it matters: Believing public attributes are protected can lead to unexpected bugs when other code changes data unexpectedly.

Quick: Do you think Python enforces attribute privacy strictly? Commit yes or no.

Common Belief: Python enforces strict privacy rules on attributes starting with underscores.

Reality: Python uses naming conventions and name mangling but does not strictly prevent access to any attribute.

Why it matters: Assuming strict privacy can cause confusion when accessing or debugging attributes that seem hidden but are accessible.

Quick: Do you think public attributes always hold valid data automatically? Commit yes or no.

Common Belief: Public attributes always contain valid and safe data because they belong to the object.

Reality: Public attributes can hold any value, including invalid or unexpected data, unless controlled by methods.

Why it matters: Ignoring this can cause programs to behave incorrectly or crash due to invalid attribute values.

Expert Zone

1

Public attributes are stored in the object's __dict__, making attribute access a dictionary lookup, which can be customized with __slots__ for memory optimization.

2

Python's philosophy trusts the programmer, so public attributes rely on conventions rather than enforced access control, which differs from many other languages.

3

Using public attributes with property decorators allows seamless switching between direct access and controlled access without changing the interface.

When NOT to use

Public attributes are not suitable when you need to protect data integrity strictly or hide implementation details. In such cases, use private attributes with name mangling or properties with getter/setter methods to control access.

Production Patterns

In real-world Python code, public attributes are often used for simple data containers or configuration objects. For sensitive data or complex validation, properties or data classes with validation methods are preferred. Frameworks like Django use public attributes for model fields but add validation layers.

Connections

Encapsulation

Public attributes relate to encapsulation as the simplest form without access control.

Understanding public attributes clarifies the base level of encapsulation and why more control mechanisms exist.

Data Hiding in Object-Oriented Programming

Public attributes are the opposite of data hiding, which restricts access to internal data.

Knowing public attributes helps appreciate the need for data hiding to prevent unintended interference.

Open Systems Design (Engineering)

Public attributes resemble open interfaces in system design where components expose data freely.

Recognizing this connection shows how openness vs. protection is a common design tradeoff across fields.

Common Pitfalls

#1 Changing public attributes without validation leads to invalid object states.

Wrong approach:

my_car.color = 123 # Assigning a number instead of a color string

Correct approach:

def set_color(self, color):
if isinstance(color, str):
self.color = color
else:
print('Invalid color')

my_car.set_color('blue')

Root cause:

Assuming public attributes are safe to change without checks causes invalid data.

#2 Assuming attributes starting with underscore are private and safe from outside access.

Wrong approach:

print(my_object._hidden_attr) # Accessing supposed private attribute directly

Correct approach:

# Use methods or properties to access _hidden_attr instead
value = my_object.get_hidden_attr()

Root cause:

Misunderstanding Python's naming conventions as strict privacy leads to accidental misuse.

#3 Overusing public attributes for complex data without encapsulation.

Wrong approach:

class BankAccount:
def __init__(self):
self.balance = 0 # public attribute

account = BankAccount()
account.balance = -100 # Invalid state allowed

Correct approach:

class BankAccount:
def __init__(self):
self.__balance = 0 # private attribute
def deposit(self, amount):
if amount > 0:
self.__balance += amount
def get_balance(self):
return self.__balance

account = BankAccount()
account.deposit(100)
print(account.get_balance()) # 100

Root cause:

Not protecting critical data with methods or private attributes allows invalid states.

Key Takeaways

Public attributes are variables attached to objects that anyone can access or change freely.

They make storing and sharing data inside objects simple but offer no protection against invalid changes.

Python trusts programmers to use public attributes responsibly, relying on conventions rather than strict rules.

For safety and control, public attributes can be combined with methods or replaced by properties.

Understanding public attributes is essential before learning about private attributes and encapsulation.