1. type()
Description: Returns the type of an object.
python
# 1. Basic types
print(type(5)) # <class 'int'>
print(type(3.14)) # <class 'float'>
print(type("hello")) # <class 'str'>
print(type(True)) # <class 'bool'>
# 2. Collection types
print(type([1, 2, 3])) # <class 'list'>
print(type((1, 2, 3))) # <class 'tuple'>
print(type({1, 2, 3})) # <class 'set'>
print(type({"a": 1})) # <class 'dict'>
# 3. Special types
print(type(None)) # <class 'NoneType'>
print(type(print)) # <class 'builtin_function_or_method'>
2. isinstance()
Description: Checks if object is instance of specified type(s).
python
# 1. Check basic types
print(isinstance(5, int)) # True
print(isinstance(3.14, float)) # True
print(isinstance("hello", str)) # True
# 2. Check multiple types
print(isinstance(5, (int, float))) # True
print(isinstance(3.14, (int, str))) # False
# 3. Check collection types
print(isinstance([1, 2], list)) # True
print(isinstance((1, 2), tuple)) # True
# 4. Check with None
print(isinstance(None, type(None))) # True
# 5. Check function type
def my_func(): pass
print(isinstance(my_func, type(my_func))) # True
# 6. Check string or list
print(isinstance("test", (str, list))) # True
# 7. Check number types
print(isinstance(10, (int, float, complex))) # True
# 8. Check boolean
print(isinstance(True, bool)) # True
# 9. Check dictionary
print(isinstance({"a": 1}, dict)) # True
# 10. Check set
print(isinstance({1, 2}, set)) # True
3. hasattr()
Description: Checks if object has specified attribute.
python
# 1. Check string methods
s = "hello"
print(hasattr(s, 'upper')) # True
print(hasattr(s, 'split')) # True
# 2. Check list methods
lst = [1, 2, 3]
print(hasattr(lst, 'append')) # True
print(hasattr(lst, 'pop')) # True
# 3. Check dictionary methods
d = {"a": 1}
print(hasattr(d, 'keys')) # True
print(hasattr(d, 'values')) # True
# 4. Check built-in functions
print(hasattr(print, '__name__')) # True
# 5. Check number attributes
x = 10
print(hasattr(x, 'real')) # True
print(hasattr(x, 'imag')) # True
# 6. Check module attributes
import math
print(hasattr(math, 'pi')) # True
# 7. Check non-existent attributes
print(hasattr("hello", 'nonexistent')) # False
# 8. Check tuple methods
t = (1, 2, 3)
print(hasattr(t, 'count')) # True
# 9. Check set methods
s = {1, 2, 3}
print(hasattr(s, 'add')) # True
# 10. Check function attributes
def func(): pass
print(hasattr(func, '__name__')) # True
4. getattr()
Description: Gets the value of an attribute.
python
# 1. Get string methods
s = "hello"
upper_method = getattr(s, 'upper')
print(upper_method()) # HELLO
# 2. Get list methods
lst = [1, 2, 3]
append_method = getattr(lst, 'append')
append_method(4)
print(lst) # [1, 2, 3, 4]
# 3. Get with default value
d = {"a": 1}
value = getattr(d, 'nonexistent', 'default')
print(value) # default
# 4. Get number attributes
x = 5 + 3j
print(getattr(x, 'real')) # 5.0
print(getattr(x, 'imag')) # 3.0
# 5. Get built-in constants
import math
print(getattr(math, 'pi')) # 3.141592653589793
# 6. Get function attributes
def greet(): return "Hello"
print(getattr(greet, '__name__')) # greet
# 7. Get dictionary methods
d = {"a": 1}
keys_method = getattr(d, 'keys')
print(list(keys_method())) # ['a']
# 8. Get tuple methods
t = (1, 2, 2, 3)
count_method = getattr(t, 'count')
print(count_method(2)) # 2
# 9. Get module functions
import random
rand_func = getattr(random, 'randint')
print(rand_func(1, 10)) # Random number between 1-10
# 10. Get set methods
my_set = {1, 2, 3}
add_method = getattr(my_set, 'add')
add_method(4)
print(my_set) # {1, 2, 3, 4}
5. id()
Description: Returns unique identity (memory address) of object.
python
# 1. IDs of integers
a = 5
b = 5
print(id(a)) # Same as id(b) due to caching
print(id(a) == id(b)) # True
# 2. IDs of strings
s1 = "hello"
s2 = "hello"
print(id(s1) == id(s2)) # True (string interning)
# 3. IDs of different objects
lst1 = [1, 2, 3]
lst2 = [1, 2, 3]
print(id(lst1) == id(lst2)) # False
# 4. ID of None
print(id(None)) # Always the same
# 5. ID after modification
x = [1, 2]
original_id = id(x)
x.append(3)
print(id(x) == original_id) # True
# 6. IDs of functions
def func1(): pass
def func2(): pass
print(id(func1) == id(func2)) # False
# 7. ID of built-in functions
print(id(print)) # Unique ID
# 8. IDs of boolean values
print(id(True)) # Always same
print(id(False)) # Always same
# 9. ID of empty collections
empty_list = []
empty_dict = {}
print(id(empty_list) != id(empty_dict)) # True
# 10. ID comparison with is operator
a = [1, 2]
b = a
print(id(a) == id(b)) # True
6. dir()
Description: Returns list of valid attributes for object.
python
# 1. Dir of string
s = "hello"
print('upper' in dir(s)) # True
print('split' in dir(s)) # True
# 2. Dir of list
lst = [1, 2, 3]
print('append' in dir(lst)) # True
print('pop' in dir(lst)) # True
# 3. Dir of dictionary
d = {"a": 1}
print('keys' in dir(d)) # True
print('values' in dir(d)) # True
# 4. Dir of number
x = 10
print('real' in dir(x)) # True
print('imag' in dir(x)) # True
# 5. Dir of function
def func(): pass
print('__name__' in dir(func)) # True
# 6. Dir of module
import math
math_attrs = dir(math)
print('sqrt' in math_attrs) # True
print('pi' in math_attrs) # True
# 7. Dir of None
none_attrs = dir(None)
print('__class__' in none_attrs) # True
# 8. Dir of boolean
print(dir(True)) # Shows bool attributes
# 9. Dir of tuple
t = (1, 2, 3)
print('count' in dir(t)) # True
print('index' in dir(t)) # True
# 10. Dir without arguments (current scope)
local_vars = dir()
print('__name__' in local_vars) # True
7. repr()
Description: Returns official string representation of object.
python
# 1. String representation
s = "hello"
print(repr(s)) # "'hello'"
# 2. Number representation
print(repr(123)) # '123'
print(repr(3.14)) # '3.14'
# 3. List representation
lst = [1, 2, 3]
print(repr(lst)) # '[1, 2, 3]'
# 4. Dictionary representation
d = {"a": 1, "b": 2}
print(repr(d)) # "{'a': 1, 'b': 2}"
# 5. Tuple representation
t = (1, 2, 3)
print(repr(t)) # '(1, 2, 3)'
# 6. Set representation
s = {1, 2, 3}
print(repr(s)) # '{1, 2, 3}'
# 7. None representation
print(repr(None)) # 'None'
# 8. Boolean representation
print(repr(True)) # 'True'
print(repr(False)) # 'False'
# 9. Special characters in strings
s = "hello\nworld"
print(repr(s)) # "'hello\\nworld'"
# 10. Function representation
def greet(): return "Hello"
print(repr(greet)) # '<function greet at 0x...>'
These functions are essential for introspection, debugging, and understanding objects in Python!
I’ll explain built-in object and attribute functions in Python with 7 simple examples for each:
1. type()
Syntax: type(object) or type(name, bases, dict)
Description: Returns the type of an object or creates a new type.
Examples:
python
# 1. Check type of basic objects
print(type(5)) # <class 'int'>
print(type("hello")) # <class 'str'>
print(type([1, 2, 3])) # <class 'list'>
# 2. Check type of variables
x = 3.14
print(type(x)) # <class 'float'>
# 3. Check if object is of specific type
if type(10) == int:
print("It's an integer") # This will print
# 4. Create a new class dynamically
MyClass = type('MyClass', (), {'x': 10})
obj = MyClass()
print(obj.x) # 10
# 5. Check type of functions
def my_func():
pass
print(type(my_func)) # <class 'function'>
# 6. Check type of None
print(type(None)) # <class 'NoneType'>
# 7. Compare types
print(type(5) is int) # True
2. isinstance()
Syntax: isinstance(object, classinfo)
Description: Checks if an object is an instance of a class or tuple of classes.
Examples:
python
# 1. Check if object is integer
print(isinstance(5, int)) # True
# 2. Check if object is string or list
print(isinstance("hello", (str, list))) # True
# 3. Check with custom class
class Dog:
pass
my_dog = Dog()
print(isinstance(my_dog, Dog)) # True
# 4. Check inheritance
class Animal:
pass
class Cat(Animal):
pass
my_cat = Cat()
print(isinstance(my_cat, Animal)) # True (inheritance)
# 5. Check with built-in types
numbers = [1, 2, 3]
print(isinstance(numbers, list)) # True
# 6. Check multiple types
value = 3.14
print(isinstance(value, (int, float))) # True
# 7. Check with None
print(isinstance(None, type(None))) # True
3. issubclass()
Syntax: issubclass(class, classinfo)
Description: Checks if a class is a subclass of another class.
Examples:
python
# 1. Basic inheritance check
class Animal:
pass
class Dog(Animal):
pass
print(issubclass(Dog, Animal)) # True
# 2. Check with built-in types
print(issubclass(bool, int)) # True (bool is subclass of int)
# 3. Multiple inheritance check
class A: pass
class B(A): pass
class C(B): pass
print(issubclass(C, A)) # True
# 4. Check with tuple of classes
print(issubclass(str, (int, str))) # True
# 5. Class is subclass of itself
print(issubclass(Animal, Animal)) # True
# 6. Check with non-inheritance
class Bird: pass
print(issubclass(Bird, Animal)) # False
# 7. Built-in type hierarchy
print(issubclass(list, object)) # True (all classes inherit from object)
4. id()
Syntax: id(object)
Description: Returns the unique identity (memory address) of an object.
Examples:
python
# 1. Get ID of integers
x = 5
print(id(x)) # e.g., 140735849845792
# 2. Compare IDs of same values
a = 10
b = 10
print(id(a) == id(b)) # True (small integers are cached)
# 3. Different objects have different IDs
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(id(list1) == id(list2)) # False
# 4. ID remains same for same object
x = [1, 2, 3]
y = x
print(id(x) == id(y)) # True
# 5. ID of functions
def my_func():
pass
print(id(my_func)) # Unique ID
# 6. ID after modification
lst = [1, 2]
id1 = id(lst)
lst.append(3)
id2 = id(lst)
print(id1 == id2) # True (same object modified)
# 7. ID of None
print(id(None)) # Always same ID
5. hasattr()
Syntax: hasattr(object, name)
Description: Checks if an object has an attribute with the given name.
Examples:
python
# 1. Check for string methods
s = "hello"
print(hasattr(s, 'upper')) # True
# 2. Check for list methods
lst = [1, 2, 3]
print(hasattr(lst, 'append')) # True
# 3. Check for non-existent attribute
print(hasattr(s, 'nonexistent')) # False
# 4. Check with custom class
class Person:
def __init__(self, name):
self.name = name
p = Person("Alice")
print(hasattr(p, 'name')) # True
# 5. Check for methods
print(hasattr(p, '__init__')) # True
# 6. Check with built-in objects
print(hasattr(5, 'real')) # True
# 7. Check for private attributes
class Test:
def __init__(self):
self._private = "secret"
t = Test()
print(hasattr(t, '_private')) # True
6. getattr()
Syntax: getattr(object, name[, default])
Description: Gets the value of an attribute, with optional default if not found.
Examples:
python
# 1. Get string method
s = "hello"
upper_method = getattr(s, 'upper')
print(upper_method()) # HELLO
# 2. Get attribute with default
class Person:
def __init__(self, name):
self.name = name
p = Person("Bob")
age = getattr(p, 'age', 25) # Default if attribute not found
print(age) # 25
# 3. Get built-in attributes
x = 10
print(getattr(x, 'real')) # 10
# 4. Get method and call it
lst = [1, 2, 3]
append_method = getattr(lst, 'append')
append_method(4)
print(lst) # [1, 2, 3, 4]
# 5. Get class attributes
class MyClass:
class_attr = "class value"
print(getattr(MyClass, 'class_attr')) # "class value"
# 6. Handle missing attribute
try:
value = getattr(p, 'nonexistent')
except AttributeError:
value = "default"
print(value) # "default"
# 7. Get special methods
print(getattr([], '__len__')) # <method-wrapper '__len__' of list object>
7. setattr()
Syntax: setattr(object, name, value)
Description: Sets the value of an attribute, creating it if it doesn’t exist.
Examples:
python
# 1. Set attribute on custom object
class Person:
pass
p = Person()
setattr(p, 'name', 'Charlie')
print(p.name) # Charlie
# 2. Set multiple attributes
attributes = {'age': 30, 'city': 'New York'}
for key, value in attributes.items():
setattr(p, key, value)
print(p.age, p.city) # 30 New York
# 3. Modify existing attribute
setattr(p, 'age', 31)
print(p.age) # 31
# 4. Set private attribute
setattr(p, '_secret', 'hidden')
print(p._secret) # hidden
# 5. Set class attribute
setattr(Person, 'species', 'Human')
print(Person.species) # Human
# 6. Set attribute with dynamic name
attr_name = 'dynamic_attr'
setattr(p, attr_name, 'dynamic value')
print(p.dynamic_attr) # dynamic value
# 7. Set on built-in types (usually not recommended)
# Note: This may not work for all built-in types
class CustomList(list):
pass
cl = CustomList([1, 2, 3])
setattr(cl, 'custom_attr', 'test')
print(cl.custom_attr) # test
These functions are essential for introspection and dynamic attribute handling in Python, enabling powerful meta-programming capabilities.
