When I import a module, such as sys, I am assuming that I am importing a script, and in order to access its functions, I have to use the dot notation. For example, I want to
The dot is a generic element reference, not merely a function. This says to get the stderr
element of sys
, then get the write
element of stderr
. For this to work, stderr
must be an object that contains elements, and write
must be a function ... since the parentheses mean that we're trying to call write
.
We do have to know the general semantic of each element: which are packages, which are constants, which are functions, etc.
Once you import a module (like sys
or anything), the dot-notation may then refer to anything it contains. You could also import a 'package' contains modules, classes, methods in classes, functions in modules, etc.
>>> import sys
>>> type(sys)
<class 'module'>
>>> sys.stderr
<_io.TextIOWrapper name='<stderr>' mode='w' encoding='cp437'>
>>> type(sys.stderr)
<class '_io.TextIOWrapper'>
>>> type(sys.stderr.write)
<class 'builtin_function_or_method'>
>>>
It's meant to be generic sort-of-attribute access where each thing inside another is accessed via the dot, as if it was an attribute of that object, which it is.
I believe it's meant to be ambiguous so that the user of a module/package does not need to be concerned with the implementation details of those objects. And if they change, as long as the structure and names are maintained, the actual object it refers to is not of concern to the user. They could always use type()
or help()
to look at the details or use other introspection tools.