Python Clarification about dir() in Python

[fog37]

TL;DR Summary

better understand the type of output of dir() function

Hello,

Simple clarification about the built-in function dir() if possible: if we don't provide any argument, i.e. we use the function simply as dir(), the function displays the namespace of the function, of the module, etc.

However, if we provide an input, the function dir() displays a list of all the methods and attributes that that particular object has. For example, if we class, Dog(), and then we create an instances, dog1=Dog(), we can type dir(dog1) to see all the attributes and methods associated to the instance dog. Would that be equivalent to the namespace for that specific object?

In general, when talking about namespaces, we refer to local namespaces (for functions; can multiple local namespaces exist at the same time or only one at a time?), global namespaces (which pertain to modules. Can multiple global namespaces exist at once or only one at a time) and built-in namespace (only one built-in namespace exists).

In essence, does dir() show the content of a namespace or the attributes+methods of an object? Or both depending on the input to dir()?

Thanks!

 

[jack action]

dir()
dir(object)

Without arguments, return the list of names in the current local scope. With anargument, attempt to return a list of valid attributes for that object.

If the object has a method named __dir__(), this method will be called andmust return the list of attributes. This allows objects that implement a custom__getattr__() or __getattribute__() function to customize the waydir() reports their attributes.

If the object does not provide __dir__(), the function tries its best togather information from the object’s __dict__ attribute, if defined, andfrom its type object. The resulting list is not necessarily complete and maybe inaccurate when the object has a custom __getattr__().

The default dir() mechanism behaves differently with different types ofobjects, as it attempts to produce the most relevant, rather than complete, information:

• If the object is a module object, the list contains the names of the module’sattributes.
• If the object is a type or class object, the list contains the names of itsattributes, and recursively of the attributes of its bases.
• Otherwise, the list contains the object’s attributes’ names, the names of itsclass’s attributes, and recursively of the attributes of its class’s baseclasses.

The resulting list is sorted alphabetically. For example:

>>>
import struct

dir() # show the names in the module namespace
['__builtins__', '__name__', 'struct']

dir(struct) # show the names in the struct module
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
'__initializing__', '__loader__', '__name__', '__package__',
'_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
'unpack', 'unpack_from']

class Shape:

def __dir__(self):

return ['area', 'perimeter', 'location']

s = Shape()

dir(s)
['area', 'location', 'perimeter']Note
Because dir() is supplied primarily as a convenience for use at an interactive prompt, it tries to supply an interesting set of names more than it tries to supply a rigorously or consistently defined set of names, and its detailed behavior may change across releases. For example, metaclass attributes are not in the result list when the argument is a class.

 

[fog37]

Thank you jac action! Things are more clear. Also, when importing a module in our script, we can either type:

import module_name

This statement adds only the name of that specific module to the global namespace (the namespace of our script). It does NOT add the entire namespace of that module to the current global namespace.
We have to use module_name as prefix with dot notation to use the tools inside that module. This certainly avoid any type of name conflict.

The other option is the partial import:

from module_name import tool1

In this case we don't need to type the module_name as prefix but can only use tool1... However, I believe, there is potential for name conflict if the current global namespace (the namespace of our script) already has that name (tool1) inside of it The partial import only imports the name "tool1" into the global namespace...

The 3rd option is the worst: import module_name* . This command essentially fuses the module's namespace with the current global namespace and that can cause issues because the same name may be in both namespaces and Python will give priority to the one inside the global namespace...

As far as the function dir(), I guess it outputs names....so when we type dir(object), we essentially display all the names associated to that object...

Thank you!