Windows Registry Access Using Python (winreg)

Windows Registry

The Window Library comprises of a few primary keys, each containing subkeys and values. The fundamental keys are:

HKEY_CLASSES_ROOT (HKCR): Information about enlisted applications, document affiliations, and COM objects.
HKEY_CURRENT_USER (HKCU): Configuration Information for the at present signed in client.
HKEY_LOCAL_MACHINE (HKLM): Configuration Information for the nearby machine, including equipment and programming settings.
HKEY_USERS (HKU): Information pretty much all client profiles on the PC.
HKEY_CURRENT_CONFIG (HKCC): Equipment setup profiles for the nearby machine.

Each key can contain subkeys and values. Values can be of various sorts, including strings, double information, and DWORDs (32-digit whole numbers).

Windows Registry Access Using Python (winreg)

Introduction to the winreg Module

The winreg module (recently known as _winreg in Python 2) permits you to cooperate with the Windows Library. Here is an undeniable level outline of the essential capabilities gave by winreg:

winreg.OpenKey: Opens a current key.
winreg.CreateKey: Makes another key or opens a current key.
winreg.QueryValueEx: Recovers the worth related with a predefined name.
winreg.SetValueEx: Stores information in the predefined esteem field.
winreg.DeleteValue: Eliminates a named esteem from a library key.
winreg.DeleteKey: Erases a predetermined key.

Opening a Registry Key

To play out any procedure on a library key, you first need to open it. The winreg.OpenKey capability is utilized for this reason.

 
import winreg
# Open a key for reading
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r'Software\MySoftware')   

In this example, we open the MySoftware key under HKEY_CURRENT_USER. The r before the string shows a crude string, guaranteeing that oblique punctuation lines are dealt with in a real sense.

Reading a Value

To peruse a worth from an open library key, utilize the winreg.QueryValueEx capability.

 
import winreg
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r'Software\MySoftware')
value, regtype = winreg.QueryValueEx(key, 'MyValue')
print(f'The value is: {value}')   

Output:

 
The value is: 1

Here, we inquiry the worth named MyValue from the MySoftware key. The capability returns a tuple containing the worth and the kind of the information put away in the library.

Writing a Value

To compose a worth to a library key, utilize the winreg.SetValueEx capability.

 
import winreg
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r'Software\MySoftware', 0, winreg.KEY_SET_VALUE)
winreg.SetValueEx(key, 'MyValue', 0, winreg.REG_SZ, 'NewValue')
winreg.CloseKey(key)   

In this example, we open the MySoftware key with compose access (winreg.KEY_SET_VALUE), then, at that point, set the worth of MyValue to NewValue. The winreg.REG_SZ boundary shows that the worth is a string.

Creating a New Key

To make another key, utilize the winreg.CreateKey capability.

 
import winreg
key = winreg.CreateKey(winreg.HKEY_CURRENT_USER, r'Software\MyNewSoftware')
winreg.SetValueEx(key, 'MyValue', 0, winreg.REG_SZ, 'NewValue')
winreg.CloseKey(key)   

This content makes another key named MyNewSoftware under HKEY_CURRENT_USER and sets a worth named MyValue.

Deleting a Value

To delete a value from a library key, utilize the winreg.DeleteValue capability.

 
import winreg
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r'Software\MySoftware', 0, winreg.KEY_SET_VALUE)
winreg.DeleteValue(key, 'MyValue')
winreg.CloseKey(key)   

Here, we erase the worth named MyValue from the MySoftware key.

Deleting a Key

To delete a library key, utilize the winreg.DeleteKey capability.

 
import winreg
# Note: The key must be empty to be deleted
winreg.DeleteKey(winreg.HKEY_CURRENT_USER, r'Software\MyNewSoftware')   

This content erases the MyNewSoftware key. Note that the critical should be vacant (i.e., it should not contain any subkeys or values) to be erased.

Practical Examples and Use Cases

Let's look at some practical examples and use cases for controlling the Windows Vault with Python.

Example 1:< Checking for Software Installation

Assume you need to check in the event that a specific programming is introduced on the framework by searching for its vault passage.

 
import winreg
def is_software_installed(software_name):
    try:
        key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r'SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall')
        for i in range(0, winreg.QueryInfoKey(key)[0]):
            subkey_name = winreg.EnumKey(key, i)
            subkey = winreg.OpenKey(key, subkey_name)
            try:
                display_name = winreg.QueryValueEx(subkey, 'DisplayName')[0]
                if display_name == software_name:
                    return True
            except FileNotFoundError:
                continue
        return False
    except FileNotFoundError:
        return False
software_name = 'Some Software'
if is_software_installed(software_name):
    print(f'{software_name} is installed.')
else:
    print(f'{software_name} is not installed.')   

Output:

 
Some Software is installed.

This capability checks the Uninstall library key to check whether the predetermined programming is recorded.

Explanation:

The example uses the winreg module to collaborate with the Windows Vault, explicitly to check in the event that a product is introduced on the framework. It characterizes a capability is_software_installed that takes the name of the product as info. Inside this capability, it endeavors to open the Uninstall key in the Vault, where programming passages are commonly put away. By emphasizing through the subkeys under this key and checking their DisplayName values, it decides whether the predefined programming is available.

At long last, it prints a message demonstrating regardless of whether the product is introduced in view of the capability's bring esteem back. This approach gives a clear technique to inquiry programming establishment status straightforwardly from the Windows Vault.

Example 2: Adding an Application to Startup

To add an application to the framework startup, you can make a vault passage under the Run key.

 
import winreg
def add_to_startup(app_name, app_path):
    key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r'Software\Microsoft\Windows\CurrentVersion\Run', 0, winreg.KEY_SET_VALUE)
    winreg.SetValueEx(key, app_name, 0, winreg.REG_SZ, app_path)
    winreg.CloseKey(key)
app_name = 'MyApp'
app_path = r'C:\Path\To\MyApp.exe'
add_to_startup(app_name, app_path)
print(f'{app_name} added to startup.')   

Output:

 
Chrome added to startup

Explanation:

The example uses the winreg module to add an application to the framework startup. It characterizes a capability add_to_startup that takes the application name and its full way as boundaries. Inside this capability, it gets to the Run key under the ongoing client's vault hive. It then sets a vault esteem with the gave application name and way utilizing winreg.SetValueEx, successfully training Windows to send off the application upon startup. After effectively adding the passage, it shuts the library key. At long last, it prints an affirmation message demonstrating that the application has been added to the startup. This approach offers a clear method for computerizing application startup conduct on Windows situation through library control.

This content adds an application to the startup list so it runs naturally when the client signs in.

Example 3: Reading System Information

You can utilize the library to peruse framework Information like the Windows adaptation.

 
import winreg
def get_windows_version():
    key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r'SOFTWARE\Microsoft\Windows NT\CurrentVersion')
    product_name = winreg.QueryValueEx(key, 'ProductName')[0]
    release_id = winreg.QueryValueEx(key, 'ReleaseId')[0]
    current_build = winreg.QueryValueEx(key, 'CurrentBuild')[0]
    winreg.CloseKey(key)
    return product_name, release_id, current_build
product_name, release_id, current_build = get_windows_version()
print(f'Windows Version: {product_name} (Release {release_id}, Build {current_build})')   

This capability recovers and prints the Windows adaptation Information from the vault.

Handling Registry Permissions

While working with the vault, you might experience authorization issues. Some library keys are safeguarded and require raised honors (manager privileges) to adjust. You can deal with these issues by getting special cases and illuminating the client.

 
import winreg
def safe_write_registry_value(key_path, value_name, value_Information):
    try:
        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path, 0, winreg.KEY_SET_VALUE)
        winreg.SetValueEx(key, value_name, 0, winreg.REG_SZ, value_Information)
        winreg.CloseKey(key)
    except PermissionError:
        print(f'Permission denied: Unable to write to {key_path}')
key_path = r'Software\MySoftware'
value_name = 'MyValue'
value_Information = 'NewValue'
safe_write_registry_value(key_path, value_name, value_Information)  

In this example, we get the PermissionError special case and print a message on the off chance that the activity flops because of lacking consents.

Advanced Registry Operations

Enumerating Subkeys and Values

You can count subkeys and values inside a key utilizing winreg.EnumKey and winreg.EnumValue.

 
import winreg
def list_subkeys_and_values(key_path):
    try:
        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path)
        subkeys = []
        values = []
        # Enumerate subkeys
        i = 0
        while True:
            try:
                subkey = winreg.EnumKey(key, i)
                subkeys.append(subkey)
                i += 1
            except OSError:
                break
        # Enumerate values
        i = 0
        while True:
            try:
                value = winreg.EnumValue(key, i)
                values.append(value)
                i += 1
            except OSError:
                break
        winreg.CloseKey(key)
        return subkeys, values
    except FileNotFoundError:
        return None, None
key_path = r'Software\MySoftware'
subkeys, values = list_subkeys_and_values(key_path)
if subkeys is not None and values is not None:
    print(f'Subkeys: {subkeys}')
    print(f'Values: {values}')
else:
    print(f'Key not found: {key_path}')   

This capability records all subkeys and values under a predefined vault key.

Modifying Binary and DWORD Values

The winreg module upholds various kinds of values, including twofold (winreg.REG_BINARY) and DWORD (winreg.REG_DWORD). This is the way to peruse and compose these kinds of values.

 
import winreg
# Writing a DWORD value
def write_dword_value(key_path, value_name, value_Information):
    key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path, 0, winreg.KEY_SET_VALUE)
    winreg.SetValueEx(key, value_name, 0, winreg.REG_DWORD, value_Information)
    winreg.CloseKey(key)
# Reading a DWORD value
def read_dword_value(key_path, value_name):
    key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path)
    value, regtype = winreg.QueryValueEx(key, value_name)
    winreg.CloseKey(key)
    return value
key_path = r'Software\MySoftware'
value_name = 'MyDwordValue'
value_Information = 1
# Write a DWORD value
write_dword_value(key_path, value_name, value_Information)
# Read the DWORD value
dword_value = read_dword_value(key_path, value_name)
print(f'Read DWORD value: {dword_value}')   

Conclusion:

The topic shows a clear strategy to add an application to the framework startup on Windows utilizing Python and the winreg module. By getting to the Run key in the Windows Vault, the content sets a library esteem with the application's name and way, guaranteeing that the predetermined application dispatches naturally upon client login. This approach gives a helpful method for tweaking framework startup conduct, permitting clients to smooth out their work process via mechanizing the send-off of regularly utilized applications. Be that as it may, it's vital for practice alert while making changes to the Windows Vault, as inaccurate alterations might possibly affect framework soundness. In general, this content offers a straightforward yet successful answer for overseeing startup applications on Windows frameworks automatically.

Next Topic3 easy ways to compare two pandas dataframes

← prev next →