7.5 Objects

• >Objects are very fundamental in Python. They are Python’s abstraction for data. All data in a Python program is represented by objects or by relations between objects.
• >Every object has an identity, a type and a value. Identity is the representation of its address in the memory, type is the class it is instantiated from and value is the data it contains.
• >The value can/cannot be changed depending on mutable and immutable object types. For example, a container object (like list/tuple) can have its own data/attributes/variables (which can be any data-type/data-structure/object). And depending on the type of object, they have their own functions (called methods).

"Everything in Python is an object."

• >Python is designed around Objects, as it is an object oriented programming language.
• >The Data Types & Data Structures are objects as they have their own attributes/methods. Functions are first class as we saw earlier & Classes are created by metaclasses, so they both are objects too. Modules (in next Chapter) when imported can also have their own attributes/methods, so they are objects too. And so as a property of an object, they all can be assigned to a variable or passed to or returned from a function.
• >So in summary, everything except for Keywords & Operators is considered as an object in Python.
• >We saw earlier how to create an instance of a class (i.e object) and how to access their variables/methods, here we'll see some examples of everything being an object.

## Data types are object, eg. integer is object of class 'int'
a = 30
print(type(a))  # <class 'int'>
# print some attributes/methods of class int
print(dir(a)[:3]) # ['__abs__', '__add__', '__and__']


## Data structures are object, eg list is object of class 'list'
a = [30, 10, 20]
print(type(a))  # <class 'list'>
# print some attributes/methods of class list
print(dir(a)[:3]) # ['__add__', '__class__', '__class_getitem__']


## Functions are objects of class 'function'
def my_fun(): pass
print(type(my_fun))  # <class 'function'>


## Classes are objects of a metaclass 'type'
class MyClass: pass
print(MyClass.__class__)  # <class 'type'>

• >Some functions for objects.

class DummyClass:
  def some_method():
      pass

my_instance = DummyClass()

# Check if a object has some attribute
print(hasattr(my_instance, "x"))  # False

# Use 'getattr()' to get the value of a object's attribute,
# it's similar to accessing with '.' operator though one benefit is
# if the attribute is not found, the provided 'default_value' is returned
# Syntax: getattr(<object>, "<attribute_name>", <default_value>)
print(getattr(my_instance, "x", 42))  # 42

# Set value to a object's attribute, similar to assigning with '=' operator
setattr(my_instance, "my_new_var", "Hello")
print(my_instance.my_new_var)  # Hello

# Delete a object's attribute, returns nothing and raises
# 'AttributeError' if not found
delattr(my_instance, "my_new_var")
print(my_instance.my_new_var)  # AttributeError
delattr(my_instance, "my_new_var")  # AttributeError