dir([object])

# Example 1: Names in current local scope
print(dir())

# Example 2: Names of an object's attributes
my_list = [1, 2, 3]
print(dir(my_list))

import pandas as pd

# Discover available methods and attributes
print(dir(pd))

# Explore DataFrame methods
df = pd.DataFrame({'A': [1, 2, 3]})
methods = [method for method in dir(df) if not method.startswith('_')]
print(methods)

class DataProcessor:
    def __init__(self):
        self.data = []
        self.processed = False

    def process(self):
        self.processed = True

processor = DataProcessor()
print(dir(processor))
# Output includes: 'data', 'process', 'processed', and inherited methods

# Quick check of string methods
text = "hello"
string_methods = [m for m in dir(text) if not m.startswith('_')]
print(string_methods)
# ['capitalize', 'casefold', 'center', 'count', 'encode', ...]

def get_public_attributes(obj):
    """Get all public attributes and methods of an object."""
    return [attr for attr in dir(obj) if not attr.startswith('_')]

my_list = [1, 2, 3]
public_attrs = get_public_attributes(my_list)
print(public_attrs)
# ['append', 'clear', 'copy', 'count', 'extend', 'index', ...]

import numpy as np

# Discover what numpy offers
print(f"NumPy version: {np.__version__}")
print(f"NumPy type: {type(np)}")

# Get specific function info
functions = [name for name in dir(np) if callable(getattr(np, name))]
print(f"NumPy has {len(functions)} callable functions")

# Use help() for detailed info on specific items
help(np.array)

class Vehicle:
    wheels = 4

    def __init__(self, brand):
        self.brand = brand
        self._private = "private data"

    def drive(self):
        return f"{self.brand} is driving"

car = Vehicle("Toyota")
print(dir(car))

# Separate class attributes from instance attributes
class_attrs = dir(Vehicle)
instance_attrs = dir(car)
unique_to_instance = set(instance_attrs) - set(class_attrs)
print(f"Instance-specific attributes: {unique_to_instance}")

class Example:
    class_var = "I'm a class variable"

    def __init__(self):
        self.instance_var = "I'm an instance variable"

obj = Example()

# dir() shows all attributes including inherited and magic methods
print("dir():", len(dir(obj)))  # ~35+ items

# vars() shows only instance dictionary
print("vars():", vars(obj))     # {'instance_var': "I'm an instance variable"}

# dir() - Quick list of what's available
print(dir(dict))

# help() - Detailed documentation
help(dict.keys)  # Shows full docstring and usage

value = 42

# type() tells you what it is
print(type(value))  # <class 'int'>

# dir() tells you what it can do
print(dir(value))   # ['__abs__', '__add__', 'bit_length', ...]

def show_methods(obj, pattern=""):
    """Show methods matching a pattern."""
    methods = [m for m in dir(obj) if pattern.lower() in m.lower()]
    return methods

# Find all methods containing 'append'
my_list = []
print(show_methods(my_list, "append"))  # ['append']

# Find all string formatting methods
print(show_methods("", "format"))  # ['format', 'format_map']

class APIClient:
    """Example API client with various methods."""

    def get(self): pass
    def post(self): pass
    def delete(self): pass

    @staticmethod
    def available_methods():
        """Return list of available API methods."""
        return [m for m in dir(APIClient)
                if not m.startswith('_') and callable(getattr(APIClient, m))]

print(APIClient.available_methods())

class Config:
    debug = True
    timeout = 30
    retries = 3

config = Config()

# List all configuration options
config_options = [attr for attr in dir(config)
                 if not attr.startswith('_') and not callable(getattr(config, attr))]

print("Configuration options:")
for option in config_options:
    value = getattr(config, option)
    print(f"  {option}: {value}")

import timeit

# Calling dir() repeatedly
setup = "obj = list(range(100))"

# Measure performance
time = timeit.timeit('dir(obj)', setup=setup, number=10000)
print(f"Time for 10,000 calls: {time:.4f} seconds")

# Tip: Cache results if calling repeatedly in loops
cached_methods = dir([])
# Use cached_methods instead of calling dir() again

# Problem: dir() returns too many items including magic methods
obj = "hello"
print(len(dir(obj)))  # 78 items!

# Solution: Filter out magic methods
public_only = [attr for attr in dir(obj) if not attr.startswith('_')]
print(len(public_only))  # 44 items

class Parent:
    parent_method = "from parent"

class Child(Parent):
    child_method = "from child"

child = Child()

# All attributes including inherited
all_attrs = dir(child)

# Only child-specific
child_specific = set(dir(child)) - set(dir(Parent))
print(f"Child-specific: {child_specific}")

class DynamicClass:
    def __getattr__(self, name):
        return f"Dynamic: {name}"

obj = DynamicClass()

# dir() won't show dynamically created attributes
print(dir(obj))  # Doesn't show dynamic attributes

# They're still accessible
print(obj.anything)  # "Dynamic: anything"

# Bad: Using dir() to check for attribute
if 'append' in dir(my_list):
    my_list.append(value)

# Good: Use hasattr() instead
if hasattr(my_list, 'append'):
    my_list.append(value)

# Better: Just use try/except or duck typing
try:
    my_list.append(value)
except AttributeError:
    print("Object doesn't support append")