Understanding sys Module Attributes
$ python >>> import sys # get names of attributes in sys module >>> dir(sys) ['__displayhook__', '__doc__', 'argv', 'builtin_module_names', 'version', 'version_info'] # only few entries shown here >>> dir() ['__builtins__', '__doc__', '__name__', '__package__']
Why Runtime Details Matter
When Python code behaves unexpectedly, the first question is often where the behavior diverged. The answer can depend on the Python version, the operating system, and the logging configuration. Python's Standard Library provides tools for inspecting these runtime details and for routing debugging output to an appropriate location.
The sys module exposes information about the Python runtime. The platform and os modules help code respond to the operating system, while logging records what the program does.
Reading sys.version_info
sys.version_info is a named tuple that breaks a Python version into major, minor, micro, and releaselevel components. Because these components are already separated, code can use version-specific logic without parsing a version string.
The important idea is not a particular version value. It is the structure: the runtime version is available as separate named components. This makes version-specific checks clearer than treating the entire version as one string.
Inspecting Module Names
dir(sys) lists names available in the sys module. The source shows entries including __displayhook__, __doc__, argv, builtin_module_names, version, and version_info. By contrast, dir() lists names available in the current namespace. The source shows entries including __builtins__, __doc__, __name__, and __package__.
| Inspection | What it lists | Source examples |
|---|---|---|
| dir(sys) | Names in the sys module namespace | __displayhook__, argv, version, version_info |
| dir() | Names in the current namespace | __builtins__, __doc__, __name__, __package__ |
Tracing the Platform Branch
What do you think happens?
When the platform string starts with Windows, which path-construction branch runs?
Reveal answer
Answer: The Windows branch using HOMEDRIVE and HOMEPATH
The condition platform.platform().startswith('Windows') is evaluated first. If it is True, the if block runs; otherwise, the else block runs.
import os import platform import logging if platform.platform().startswith('Windows'): logging_file = os.path.join( os.environ['HOMEDRIVE'] + os.environ['HOMEPATH'], 'test.log' ) else: logging_file = os.path.join( os.environ['HOME'], 'test.log' ) logging.basicConfig(filename=logging_file, level=logging.DEBUG)
Building Portable Paths
The logical destination is the same in both branches: a file named test.log in the user's home location. The base location is obtained differently. Windows uses HOMEDRIVE and HOMEPATH, while Unix-like systems use HOME.
os.path.join() handles the platform-specific path separator automatically. The source describes a backslash on Windows and a forward slash on Unix-like systems. This allows the code to express the path construction once while letting os.path.join() produce the appropriate separator for the operating system.
| Detected platform | Base environment value | File added | Path construction |
|---|---|---|---|
| Windows | HOMEDRIVE + HOMEPATH | test.log | os.path.join(base, 'test.log') |
| Unix-like systems | HOME | test.log | os.path.join(base, 'test.log') |
The branch selects the base location; os.path.join adds the filename with the platform-appropriate separator.
Filtering Logging Output
Logging levels act as filters. DEBUG captures all messages, while WARNING and above discard lower-severity messages. In the traced script, logging.basicConfig() uses the selected logging_file path and sets the level to DEBUG, so the configured destination receives messages at DEBUG level and above.
Following the Log Destination
Trace how the script determines where logging output goes.
Detect: The script evaluates whether platform.platform() starts with Windows.
Select: A True result selects HOMEDRIVE and HOMEPATH; a False result selects HOME.
Join: os.path.join combines the selected base location with test.log using the platform-specific separator.
Configure: logging.basicConfig receives logging_file as the output path and DEBUG as the logging level.
The final logging destination depends on the selected platform branch, while the logging filter is DEBUG level and above.
Mistakes in Runtime Inspection
Treating dir() as if it listed the sys module.
dir(sys) lists names in sys, whereas dir() lists names in the current namespace.
Fix:
Pass sys explicitly when the goal is to inspect the sys module.Parsing the complete Python version as a string.
sys.version_info already separates the major, minor, micro, and releaselevel components.
Fix:
Inspect the named components of sys.version_info for version-specific logic.Building a path with one operating system's separator everywhere.
Windows and Unix-like systems use different path separators.
Fix:
Use os.path.join() so the separator is handled for the current platform.Looking only at the logging call and ignoring the branch that created logging_file.
The output path is chosen before logging.basicConfig() runs.
Fix:
Trace the condition, the selected environment variables, the join operation, and then logging.basicConfig().
Practice the Trace
Using the traced script, write down the execution order before looking back at the explanation. Identify the condition that is evaluated first, the environment variables used by each branch, the operation that adds test.log, and the arguments passed to logging.basicConfig().
Hints
- Start with platform.platform().startswith('Windows').
- The True branch uses HOMEDRIVE and HOMEPATH; the False branch uses HOME.
- Both branches use os.path.join() with test.log.
- The final configuration uses logging_file and the DEBUG level.
- Inspect sys.version_info to identify the available version components.
- Use dir(sys) when you need names from the sys module and dir() when you need names from the current namespace.
- Evaluate the platform condition before deciding which environment variables supply the base path.
- Follow the selected branch into os.path.join() and note that test.log is added in either branch.
- Check logging.basicConfig() to identify the output path and logging level.
Key Takeaways
- sys.version_info provides named major, minor, micro, and releaselevel components for the current Python runtime.
- dir(sys) inspects the sys module namespace, while dir() inspects the current namespace.
- Platform detection selects either the Windows environment variables or the HOME environment variable.
- os.path.join() constructs the final path with the separator appropriate to the operating system.
- Logging levels filter messages, and logging.basicConfig() connects the selected path and level to the logging configuration.
Key Takeaways
- Use sys.version_info to inspect Python version components without parsing a version string.
- Use dir(sys) and dir() deliberately because they inspect different namespaces.
- Trace platform detection before tracing path construction.
- Use os.path.join() for paths that work across Windows and Unix-like systems.
- Treat logging levels as filters and follow logging_file to understand where output is written.