Python работа с реестром windows

In this article, we will learn how to manipulate Windows Registry using winreg in Python.

What is windows registry?

It is a hierarchical database that holds low-level settings for the windows operating system and for applications in which the use of a registry is required. The device drivers, kernel, services, user interfaces, and security accounts manager can all use the registry.

IMPORTANT: As Windows Registry is a very sensitive place to do anything, do not change any value predefined by the Windows System. This article will just be for learning purposes of how Python can be used to create some new registry keys with user-defined values.

Windows registry can be used for different purposes, it can be accessed via typing regedit in the Run application.

Manipulating Windows Registry using winreg in Python

Window opens after running “regedit” in run:

Manipulating Windows Registry using winreg in Python

Creating a new Key and Assigning a new value to it.

We will be creating a new key with a user-defined value under the HKEY_CURRENT_USER as that holds information about the current user only, not many confidential system files or information, HKEY_LOCAL_MACHINE holds the information related to the system and it is better not to tamper with them or create anything new which can affect the system.

winreg module is a built-in module that installs along with Python. so, we have to just import it.

Python3

import winreg as wrg

location = wrg.HKEY_CURRENT_USER

soft = wrg.OpenKeyEx(location, r"SOFTWARE\\")

key_1 = wrg.CreateKey(soft, "Geeks")

wrg.SetValueEx(key_1, "value One", 0, wrg.REG_SZ,

               "GeeksforGeeks is Best")

wrg.SetValueEx(key_1, "value Two", 0, wrg.REG_SZ,

               "Participate in Technical Scripter")

if key_1:

    wrg.CloseKey(key_1)

Explanation of the Above Code:

  • Firstly importing the module winreg with the alias wrg, users can use anything if they want or can use winreg also every time.
  • Then defining the location where we would be creating the key and assign value.
  • Then in “soft” variable passing the location and the name of the subfolder inside OpenKeyEx() method of winreg, which is used to open already made keys, it takes two arguments, first one the main folder name and then the subfolder mentioned as ‘key’ here.
  • Then we are creating a new key whose name is Geeks inside the Software key.
  • Then last two lines are providing some values and name, the REG_SZ is mentioned as we want to use a fixed-length string here, to keep it as simple as possible.
  • After creating and assigning values it is time to close the key otherwise it will remain open and other operations can’t be done. It’s like file handling.

Output:

If we open the regedit again then we will see the following output.

Creating a new Key and Assigning a new value to it.

Note: To see the changes of anything like the creation, or deletion of keys user need to open the registry editor every time or refresh it.

Reading the contents of the created key.

Now after creating and assigning values it is time to fetch them, for that we will use the method QueryValueEx method and pass the exact location of the keys and a string that acts as a value to query. then we will close the key and print the two variables which were used to store the fetched values.

Python3

import winreg as wrg

location = wrg.HKEY_CURRENT_USER

soft = wrg.OpenKeyEx(location,r"SOFTWARE\\Geeks\\")

value_1 = wrg.QueryValueEx(soft,"Value One")

value_2 = wrg.QueryValueEx(soft,"Value Two")

if soft:

    wrg.CloseKey(soft)

print(value_1)

print(value_2)

Output:

Reading the contents of the created key.

Delete a particular value from a Key

Now we will delete that particular key that we made earlier. But if a key has some value associated with it then we can’t delete the Key directly, we first have to delete the value. Using the below code we can delete the values. Here I will be deleting just one to show how it works, user might delete all the values if they want.

Python3

import winreg as wrg

location = wrg.HKEY_CURRENT_USER

soft = wrg.OpenKeyEx(location, r"SOFTWARE\\")

key_1 = wrg.CreateKey(soft, "Geeks")

del_val_one = wrg.DeleteValue(key_1, "Value One")

del_val_two = wrg.DeleteValue(key_1, "Value Two")

if key_1:

    wrg.CloseKey(key_1)

The above code deletes both the values, if the user wants they can only delete one, then after refreshing the registry editor there must be one value left.

Note: Remember to close the key after deletion otherwise this will not work as expected.

Output:

Delete a particular value from a Key

Deleting the Key

Now after clearing the key (deleting the values) it is time to Delete the key itself.

Python3

import winreg as wrg

location = wrg.HKEY_CURRENT_USER

soft = wrg.OpenKeyEx(location, r"SOFTWARE\\")

key_1 = wrg.CreateKey(soft, "Geeks")

del_key = wrg.DeleteKey(key_1, "")

if key_1:

    wrg.CloseKey(key_1)

DeleteKey also takes two parameters one is the key and the second one is the subkey, as we have already removed all those subkeys we have passed a blank string here (remember don’t even use space, it will be considered as a character).

Output: No Geeks key is there anymore.

Deleting the Key

Last Updated :
16 Dec, 2022

Like Article

Save Article

Источник

Модуль winreg в Python позволяет получать доступ к реестру Windows и изменять его. Реестр представляет собой иерархическую базу данных, в которой хранятся параметры конфигурации операционной системы, приложений и аппаратных устройств.

Чтобы использовать модуль winreg , сначала необходимо импортировать его в скрипт Python. Затем вы можете использовать функцию ConnectRegistry() для подключения к реестру. Функция ConnectRegistry() принимает один аргумент — корневой ключ куста реестра, к которому вы хотите подключиться. Корневые ключи:

  • HKEY_CURRENT_USER : Куст реестра текущего пользователя.
  • HKEY_LOCAL_MACHINE : Куст реестра локального компьютера.
  • HKEY_CLASSES_ROOT : Куст реестра для ассоциаций файлов и классов COM.
  • HKEY_USERS : Куст реестра для всех пользователей на локальном компьютере.
  • HKEY_CURRENT_CONFIG : Куст реестра для текущей конфигурации оборудования.

После подключения к реестру вы можете использовать функцию OpenKey() , чтобы открыть определенный раздел реестра. Функция OpenKey() принимает два аргумента: дескриптор корневого ключа, к которому вы подключились на предыдущем шаге, и путь к ключу реестра, который вы хотите открыть.

Если вы хотите создать новый раздел реестра, вы можете использовать функцию CreateKey() . Функция CreateKey() принимает те же два аргумента, что и функция OpenKey() .

Чтобы прочитать значение ключа реестра, вы можете использовать функцию QueryValueEx() . Функция QueryValueEx() принимает три аргумента: дескриптор раздела реестра, который вы хотите прочитать, имя значения, которое вы хотите прочитать, и переменную для хранения значения.

Чтобы записать значение в ключ реестра, вы можете использовать функцию SetValueEx() . Функция SetValueEx() принимает четыре аргумента: дескриптор ключа реестра, в который вы хотите записать, имя значения, которое вы хотите записать, тип значения и значение, которое вы хотите записать.

Чтобы закрыть раздел реестра, вы можете использовать функцию CloseKey() . Функция CloseKey() принимает дескриптор раздела реестра, который вы хотите закрыть.

Вот простой пример использования модуля winreg для чтения и записи в реестр:

import winreg

# Подключитесь к реестру.
hkey = winreg.ConnectRegistry(None, winreg.HKEY_CURRENT_USER)

# Откройте ключ реестра для фона рабочего стола текущего пользователя.
key = winreg.OpenKey(hkey, "Control Panel\\Desktop", 0, winreg.KEY_READ | winreg.KEY_WRITE)

# Прочтите значение раздела реестра "Wallpaper".
wallpaper, reg_type = winreg.QueryValueEx(key, "Wallpaper")

# Запишите значение ключа реестра "Wallpaper" в новое значение.
new_wallpaper = "C:\\Users\\Public\\Pictures\\Sample Pictures\\Desert.jpg"
winreg.SetValueEx(key, "Wallpaper", reg_type, new_wallpaper)

# Закройте раздел реестра.
winreg.CloseKey(key)

# Закрываем соединение с реестром.
winreg.CloseKey(hkey)
Important
Будьте осторожны при изменении реестра Windows. Изменение неправильного раздела реестра может привести к нестабильной работе вашей системы или даже к сбою. Всегда полезно создать резервную копию реестра перед внесением каких-либо изменений.

Вот некоторые из наиболее распространенных проблем в Python winreg :

  • Неверный путь к ключу реестра
    Путь к ключу реестра — это иерархический путь к определенному ключу реестра. Если путь к ключу реестра неверен, модуль winreg не сможет получить доступ к ключу.
  • Неверная маска доступа к реестру
    Маска доступа к реестру определяет разрешения, необходимые для доступа к разделу реестра. Если маска доступа к реестру недействительна, модуль winreg выдаст исключение.
  • Попытка получить доступ к несуществующему ключу реестра
    Если раздел реестра, к которому вы пытаетесь получить доступ, не существует, модуль winreg выдаст исключение.
  • Попытка записи в раздел реестра, на запись которого у вас нет разрешения.
    Если вы попытаетесь выполнить запись в раздел реестра, на запись которого у вас нет разрешения, модуль winreg выдаст исключение.
  • Неправильное закрытие разделов реестра
    Когда вы закончите доступ к ключу реестра, важно правильно его закрыть. Если вы не закроете раздел реестра должным образом, это может привести к утечке ресурсов и другим проблемам.

Помимо этих распространенных проблем, существует ряд других потенциальных проблем, которые могут возникнуть при использовании модуля winreg . Например, модуль winreg поддерживает не все типы данных реестра, и отладка проблем с модулем winreg может быть затруднена.

Вот несколько советов, как избежать распространенных проблем с модулем winreg :

  • Double-check путь к ключу реестра
    Прежде чем попытаться получить доступ к разделу реестра, убедитесь, что путь к ключу реестра правильный. Вы можете использовать редактор реестра, чтобы проверить путь к ключу реестра.
  • Используйте правильную маску доступа к реестру
    Открывая раздел реестра, убедитесь, что вы используете правильную маску доступа к реестру. Маска доступа к реестру определяет разрешения, необходимые для доступа к ключу.
  • Прежде чем получить к нему доступ, проверьте наличие ключа реестра.
    Прежде чем попытаться получить доступ к ключу реестра, проверьте, существует ли этот ключ. Вы можете использовать функцию winreg.QueryValueEx() , чтобы проверить наличие ключа реестра.
  • Проверьте разрешение на запись в раздел реестра перед записью в него.
    Прежде чем попытаться выполнить запись в раздел реестра, проверьте, есть ли у вас разрешение на запись в этот раздел. Вы можете использовать функцию winreg.OpenKey() , чтобы проверить разрешение на запись в раздел реестра.
  • Закройте ключи реестра правильно
    Когда вы закончите доступ к ключу реестра, обязательно закройте его правильно. Вы можете использовать функцию winreg.CloseKey() , чтобы закрыть раздел реестра.

Чтобы использовать Winreg в Python, сначала необходимо импортировать модуль:

import winreg

После импорта модуля вы можете использовать его для доступа к реестру Windows. В следующем примере показано, как открыть ключ реестра и прочитать его значение:

# Откройте ключ реестра по адресу HKEY_CURRENT_USER\Software\Python\PythonCore.
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Python\PythonCore")

# Прочтите значение ключа реестра
value = winreg.QueryValueEx(key, "InstallPath")

# Close the registry key
winreg.CloseKey(key)

# Распечатываем значение ключа реестра
print(value[0])

Этот код выведет путь к каталогу установки Python.

Вы также можете использовать Winreg для создания, изменения и удаления ключей и значений реестра. Например, следующий код показывает, как создать новый раздел и значение реестра:

# Создайте новый раздел реестра по адресу HKEY_CURRENT_USER\Software\MyCompany\MyApplication.
key = winreg.CreateKey(winreg.HKEY_CURRENT_USER, r"Software\MyCompany\MyApplication")

# Установите значение ключа реестра "Hello, world!".
winreg.SetValueEx(key, "Greeting", winreg.REG_SZ, "Hello, world!")

# Закрываем ключ реестра
winreg.CloseKey(key)

Вот несколько дополнительных советов по использованию Winreg в Python:

  • Открывая ключ реестра, обязательно укажите правильные права доступа. Права доступа по умолчанию — KEY_READ , что позволяет вам читать ключ и его значения, но не изменять их. Если вам необходимо изменить ключ или его значения, вам потребуется указать право доступа KEY_WRITE .
  • При установке значения раздела реестра обязательно укажите правильный тип значения реестра. Наиболее распространенными типами значений реестра являются REG_SZ (string), REG_DWORD (DWORD) и REG_BINARY (двоичный файл data).
  • Когда вы закончите использовать ключ реестра, обязательно закройте его. Это обеспечит правильное обновление реестра и освобождение всех ресурсов, выделенных для этого ключа.

Обратите внимание, что изменение реестра Windows может быть опасным, поэтому важно соблюдать осторожность при использовании Winreg.

Эти функции предоставляют доступ к реестру Windows API к Python. Вместо использования целого числа в качестве дескриптора реестра используется handle object , чтобы гарантировать правильное закрытие дескрипторов, даже если программист не закрывает их явно.

Изменено в версии 3.3:. Несколько функций в этом модуле использовались для создания WindowsError , который теперь является псевдонимом OSError .

Functions

Этот модуль предлагает следующие функции:

winreg.CloseKey(hkey)

Закрывает ранее открытый раздел реестра. Аргумент hkey указывает ранее открытый ключ.

Note

Если hkey не закрывается с помощью этого метода (или через hkey.Close() ), он закрывается, когда объект hkey уничтожается с помощью Python.

winreg.ConnectRegistry(computer_name, key)

Устанавливает соединение с предопределенным дескриптором реестра на другом компьютере и возвращает handle object .

computer_name — имя удаленного компьютера в форме r"\\computername" . Если None , используется локальный компьютер.

key — это предопределенный дескриптор для подключения.

Возвращаемое значение — это дескриптор открытого ключа. Если функция завершается сбоем, возникает исключение OSError .

Вызывает auditing event winreg.ConnectRegistry с аргументами computer_name , key .

Изменено в версии 3.3: См. above .

winreg.CreateKey(key, sub_key)

Создает или открывает указанный ключ, возвращая handle object .

key — уже открытый ключ или один из предопределенных HKEY_* constants .

sub_key — это строка, определяющая ключ, который открывает или создает этот метод.

Если ключ является одним из предопределенных ключей, sub_key может быть None . В этом случае возвращаемый дескриптор является тем же дескриптором ключа, который был передан в функцию.

Если ключ уже существует, эта функция открывает существующий ключ.

Возвращаемое значение — это дескриптор открытого ключа. Если функция завершается сбоем, возникает исключение OSError .

Вызывает auditing event winreg.CreateKey с аргументами key , sub_key , access .

Вызывает auditing event winreg.OpenKey/result с аргументом key .

Изменено в версии 3.3: См. above .

winreg.CreateKeyEx(key, sub_key, reserved=0, access=KEY_WRITE)

Создает или открывает указанный ключ, возвращая handle object .

key — уже открытый ключ или один из предопределенных HKEY_* constants .

sub_key — это строка, определяющая ключ, который открывает или создает этот метод.

Reserved — это зарезервированное целое число, которое должно быть равно нулю. Значение по умолчанию — ноль.

доступ — это целое число, определяющее маску доступа, описывающую желаемый безопасный доступ для ключа. По умолчанию — KEY_WRITE . Другие допустимые значения см. в Access Rights .

Если ключ является одним из предопределенных ключей, sub_key может быть None . В этом случае возвращаемый дескриптор является тем же дескриптором ключа, который был передан в функцию.

Если ключ уже существует, эта функция открывает существующий ключ.

Возвращаемое значение — это дескриптор открытого ключа. Если функция завершается сбоем, возникает исключение OSError .

Вызывает auditing event winreg.CreateKey с аргументами key , sub_key , access .

Вызывает auditing event winreg.OpenKey/result с аргументом key .

Новое в версии 3.2.

Изменено в версии 3.3: См. above .

winreg.DeleteKey(key, sub_key)

Удаляет указанный ключ.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

sub_key — это строка, которая должна быть подразделом ключа, определяемого параметром key. Это значение не должно быть None , а ключ не может иметь подразделов.

Этот метод не может удалять ключи с подразделами.

Если метод завершается успешно, весь ключ, включая все его значения, удаляется. Если метод завершается неудачно, возникает исключение OSError .

Вызывает auditing event winreg.DeleteKey с аргументами key , sub_key , access .

Изменено в версии 3.3: См. above .

winreg.DeleteKeyEx(key, sub_key, access=KEY_WOW64_64KEY, reserved=0)

Удаляет указанный ключ.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

sub_key — это строка, которая должна быть подразделом ключа, определяемого параметром key. Это значение не должно быть None , а ключ не может иметь подразделов.

Reserved — это зарезервированное целое число, которое должно быть равно нулю. Значение по умолчанию — ноль.

доступ — это целое число, определяющее маску доступа, описывающую желаемый безопасный доступ для ключа. По умолчанию — KEY_WOW64_64KEY . В 32-битной Windows константы WOW64 игнорируются. Другие допустимые значения см. в Access Rights .

Этот метод не может удалять ключи с подразделами.

Если метод завершается успешно, весь ключ, включая все его значения, удаляется. Если метод завершается неудачно, возникает исключение OSError .

В неподдерживаемых версиях Windows возникает NotImplementedError .

Вызывает auditing event winreg.DeleteKey с аргументами key , sub_key , access .

Новое в версии 3.2.

Изменено в версии 3.3: См. above .

winreg.DeleteValue(key, value)

Удаляет именованное значение из раздела реестра.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

value — это строка, определяющая значение, которое нужно удалить.

Вызывает auditing event winreg.DeleteValue с аргументами key , value .

winreg.EnumKey(key, index)

Перечисляет подразделы открытого раздела реестра, возвращая строку.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

index — целое число, которое идентифицирует индекс ключа, который нужно получить.

Функция извлекает имя одного подраздела при каждом вызове. Обычно он вызывается повторно, пока не возникнет исключение OSError , указывающее, что больше доступных значений нет.

Вызывает auditing event winreg.EnumKey с аргументами key , index .

Изменено в версии 3.3: См. above .

winreg.EnumValue(key, index)

Перечисляет значения открытого ключа реестра, возвращая кортеж.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

index — целое число, которое идентифицирует индекс извлекаемого значения.

Функция извлекает имя одного подраздела при каждом вызове. Обычно он вызывается неоднократно, пока не возникнет исключение OSError , указывающее на отсутствие дополнительных значений.

В результате получается кортеж из трех элементов:

Index

Meaning

0

Строка, идентифицирующая имя значения.

1

Объект, содержащий данные значения, тип которого зависит от базового типа реестра.

2

Целое число, которое идентифицирует тип данных значения (см. таблицу в документации для SetValueEx() ).

Вызывает auditing event winreg.EnumValue с аргументами key , index .

Изменено в версии 3.3: См. above .

winreg.ExpandEnvironmentStrings(str)

Расширяет заполнители переменных среды %NAME% в строки типа REG_EXPAND_SZ :

>>> ExpandEnvironmentStrings('%windir%')
'C:\\Windows'

Вызывает auditing event winreg.ExpandEnvironmentStrings с аргументом str .

winreg.FlushKey(key)

Записывает все атрибуты ключа в реестр.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

Для замены ключа не обязательно звонить в К14153К. Изменения реестра сбрасываются на диск реестром с помощью ленивой программы очистки. Изменения реестра также сбрасываются на диск при завершении работы системы. В отличие от CloseKey() , метод FlushKey() возвращает результат только тогда, когда все данные записаны в реестр. Приложению следует вызывать FlushKey() только в том случае, если ему требуется абсолютная уверенность в том, что изменения реестра находятся на диске.

Note

Если вы не знаете, требуется ли вызов FlushKey() , возможно, это не так.

winreg.LoadKey(key, sub_key, file_name)

Создает подраздел под указанным ключом и сохраняет регистрационную информацию из указанного файла в этом подразделе.

key — это дескриптор, возвращаемый ConnectRegistry() или одной из констант HKEY_USERS или HKEY_LOCAL_MACHINE .

sub_key — это строка, определяющая загружаемый подраздел.

file_name — имя файла, из которого загружаются данные реестра. Этот файл должен быть создан с помощью функции SaveKey() . В файловой системе таблицы размещения файлов (FAT) имя файла может не иметь расширения.

Вызов LoadKey() завершается неудачей, если вызывающий процесс не имеет привилегии SE_RESTORE_PRIVILEGE . Обратите внимание, что привилегии отличаются от разрешений — более подробную информацию см. в RegLoadKey documentation .

Если ключ — это дескриптор, возвращаемый ConnectRegistry() , то путь, указанный в file_name, относится к удаленному компьютеру.

Вызывает auditing event winreg.LoadKey с аргументами key , sub_key , file_name .

winreg.OpenKey(key, sub_key, reserved=0, access=KEY_READ)
winreg.OpenKeyEx(key, sub_key, reserved=0, access=KEY_READ)

Открывает указанный ключ, возвращая handle object .

key — уже открытый ключ или один из предопределенных HKEY_* constants .

sub_key — это строка, которая идентифицирует sub_key, который нужно открыть.

Reserved — это зарезервированное целое число, которое должно быть равно нулю. Значение по умолчанию — ноль.

доступ — это целое число, определяющее маску доступа, описывающую желаемый безопасный доступ для ключа. По умолчанию — KEY_READ . Другие допустимые значения см. в Access Rights .

Результатом является новый дескриптор указанного ключа.

Если функция завершается сбоем, выдается OSError .

Вызывает auditing event winreg.OpenKey с аргументами key , sub_key , access .

Вызывает auditing event winreg.OpenKey/result с аргументом key .

Изменено в версии 3.2:. Разрешено использование именованных аргументов.

Изменено в версии 3.3: См. above .

winreg.QueryInfoKey(key)

Возвращает информацию о ключе в виде кортежа.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

В результате получается кортеж из трех элементов:

Index

Meaning

0

Целое число, указывающее количество дополнительных ключей, которые имеет этот ключ.

1

Целое число, указывающее количество значений этого ключа.

2

Целое число, указывающее дату последнего изменения ключа (если доступно) в виде сотен наносекунд с 1 января 1601 года.

Вызывает auditing event winreg.QueryInfoKey с аргументом key .

winreg.QueryValue(key, sub_key)

Получает безымянное значение ключа в виде строки.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

sub_key — это строка, содержащая имя подраздела, с которым связано значение. Если этот параметр равен None или пуст, функция получает значение, установленное методом SetValue() для ключа, идентифицируемого ключом.

Значения в реестре имеют имя, тип и компоненты данных. Этот метод извлекает данные для первого значения ключа, имеющего имя NULL . Но базовый вызов API не возвращает тип, поэтому, если возможно, всегда используйте QueryValueEx() .

Вызывает auditing event winreg.QueryValue с аргументами key , sub_key , value_name .

winreg.QueryValueEx(key, value_name)

Извлекает тип и данные для указанного имени значения, связанного с открытым ключом реестра.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

value_name — это строка, указывающая значение для запроса.

В результате получается кортеж из двух элементов:

Index

Meaning

0

Значение элемента реестра.

1

Целое число, указывающее тип реестра для этого значения (см. таблицу в документации для SetValueEx() ).

Вызывает auditing event winreg.QueryValue с аргументами key , sub_key , value_name .

winreg.SaveKey(key, file_name)

Сохраняет указанный ключ и все его подразделы в указанный файл.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

file_name — имя файла, в который сохраняются данные реестра. Этот файл не может уже существовать. Если это имя файла включает расширение, его нельзя использовать в файловых системах таблицы размещения файлов (FAT) методом LoadKey() .

Если ключ представляет собой ключ на удаленном компьютере, путь, описанный file_name, относится к удаленному компьютеру. Вызывающий этот метод должен обладать привилегией безопасности SeBackupPrivilege . Обратите внимание, что привилегии отличаются от разрешений — более подробную информацию см. в Conflicts Between User Rights and Permissions documentation .

Эта функция передает NULL для security_attributes в API..

Вызывает auditing event winreg.SaveKey с аргументами key , file_name .

winreg.SetValue(key, sub_key, type, value)

Связывает значение с указанным ключом.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

sub_key — это строка, определяющая подраздел, с которым связано значение.

type — целое число, определяющее тип данных. В настоящее время это должен быть REG_SZ , что означает, что поддерживаются только строки. Используйте функцию SetValueEx() для поддержки других типов данных.

value — это строка, определяющая новое значение.

Если ключ, указанный параметром sub_key, не существует, функция SetValue создает его.

Длина значений ограничена доступной памятью. Длинные значения (более 2048 байт) следует хранить в виде файлов, имена которых хранятся в реестре конфигурации. Это помогает реестру работать эффективно.

Ключ, идентифицируемый параметром key, должен быть открыт с помощью доступа KEY_SET_VALUE .

Вызывает auditing event winreg.SetValue с аргументами key , sub_key , type , value .

winreg.SetValueEx(key, value_name, reserved, type, value)

Сохраняет данные в поле значения открытого ключа реестра.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

value_name — это строка, определяющая подраздел, с которым связано значение.

зарезервировано может быть что угодно – в API. всегда передается ноль

type — целое число, определяющее тип данных. Доступные типы см. в Value Types .

value — это строка, определяющая новое значение.

Этот метод также может установить дополнительное значение и информацию о типе для указанного ключа. Ключ, идентифицируемый параметром key, должен быть открыт с доступом KEY_SET_VALUE .

Для открытия ключа используйте методы CreateKey() или OpenKey() .

Длина значений ограничена доступной памятью. Длинные значения (более 2048 байт) следует хранить в виде файлов, имена которых хранятся в реестре конфигурации. Это помогает реестру работать эффективно.

Вызывает auditing event winreg.SetValue с аргументами key , sub_key , type , value .

winreg.DisableReflectionKey(key)

Отключает отражение реестра для 32-битных процессов, работающих в 64-битной операционной системе.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

Обычно вызывает NotImplementedError , если выполняется в 32-битной операционной системе.

Если ключа нет в списке отражений, функция завершается успешно, но не оказывает никакого эффекта. Отключение отражения для ключа не влияет на отражение каких-либо подразделов.

Вызывает auditing event winreg.DisableReflectionKey с аргументом key .

winreg.EnableReflectionKey(key)

Восстанавливает отражение реестра для указанного отключенного ключа.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

Обычно вызывает NotImplementedError , если выполняется в 32-битной операционной системе.

Восстановление отражения ключа не влияет на отражение каких-либо подразделов.

Вызывает auditing event winreg.EnableReflectionKey с аргументом key .

winreg.QueryReflectionKey(key)

Определяет состояние отражения для указанного ключа.

key — уже открытый ключ или один из предопределенных HKEY_* constants .

Возвращает True , если отражение отключено.

Обычно вызывает NotImplementedError , если выполняется в 32-битной операционной системе.

Вызывает auditing event winreg.QueryReflectionKey с аргументом key .

Constants

Следующие константы определены для использования во многих функциях _winreg .

HKEY_* Constants

winreg.HKEY_CLASSES_ROOT

Записи реестра, подчиненные этому ключу, определяют типы (или классы) документов и свойства, связанные с этими типами. Приложения Shell и COM используют информацию, хранящуюся под этим ключом.

winreg.HKEY_CURRENT_USER

Записи реестра, подчиненные этому ключу, определяют предпочтения текущего пользователя. Эти настройки включают настройки переменных среды, данные о группах программ, цветах, принтерах, сетевых подключениях и настройках приложений.

winreg.HKEY_LOCAL_MACHINE

Записи реестра, подчиненные этому ключу, определяют физическое состояние компьютера, включая данные о типе шины, системной памяти, а также установленном аппаратном и программном обеспечении.

winreg.HKEY_USERS

Записи реестра, подчиненные этому разделу, определяют конфигурацию пользователя по умолчанию для новых пользователей на локальном компьютере и конфигурацию пользователя для текущего пользователя.

winreg.HKEY_PERFORMANCE_DATA

Записи реестра, подчиненные этому ключу, позволяют получить доступ к данным о производительности. Данные фактически не хранятся в реестре; функции реестра заставляют систему собирать данные из источника.

winreg.HKEY_CURRENT_CONFIG

Содержит информацию о текущем профиле оборудования локальной компьютерной системы.

winreg.HKEY_DYN_DATA

Этот ключ не используется в версиях Windows после 98.

Access Rights

Дополнительную информацию см. Registry Key Security and Access .

winreg.KEY_ALL_ACCESS

Сочетает права доступа STANDARD_RIGHTS_REQUIRED, KEY_QUERY_VALUE , KEY_SET_VALUE , KEY_CREATE_SUB_KEY , KEY_ENUMERATE_SUB_KEYS , KEY_NOTIFY и KEY_CREATE_LINK .

winreg.KEY_WRITE

Сочетает в себе права доступа STANDARD_RIGHTS_WRITE, KEY_SET_VALUE и KEY_CREATE_SUB_KEY .

winreg.KEY_READ

Сочетает значения STANDARD_RIGHTS_READ, KEY_QUERY_VALUE , KEY_ENUMERATE_SUB_KEYS и KEY_NOTIFY .

winreg.KEY_EXECUTE

Эквивалент К14153К.

winreg.KEY_QUERY_VALUE

Требуется для запроса значений ключа реестра.

winreg.KEY_SET_VALUE

Требуется для создания, удаления или установки значения реестра.

winreg.KEY_CREATE_SUB_KEY

Требуется для создания подраздела раздела реестра.

winreg.KEY_ENUMERATE_SUB_KEYS

Требуется для перечисления подразделов раздела реестра.

winreg.KEY_NOTIFY

Требуется для запроса уведомлений об изменении раздела реестра или подразделов раздела реестра.

winreg.KEY_CREATE_LINK

Зарезервировано для использования системой.

64-bit Specific

Для получения дополнительной информации см. Accessing an Alternate Registry View .

winreg.KEY_WOW64_64KEY

Указывает, что приложение в 64-разрядной версии Windows должно работать с 64-разрядным представлением реестра. В 32-битной Windows эта константа игнорируется.

winreg.KEY_WOW64_32KEY

Указывает, что приложение в 64-разрядной версии Windows должно работать с 32-разрядным представлением реестра. В 32-битной Windows эта константа игнорируется.

Value Types

Для получения дополнительной информации см. Registry Value Types .

winreg.REG_BINARY

Двоичные данные в любой форме.

winreg.REG_DWORD

32-bit number.

winreg.REG_DWORD_LITTLE_ENDIAN

32-битное число в формате с прямым порядком байтов. Эквивалент REG_DWORD .

winreg.REG_DWORD_BIG_ENDIAN

32-битное число в формате с обратным порядком байтов.

winreg.REG_EXPAND_SZ

Строка, завершающаяся Null, содержащая ссылки на переменные среды ( %PATH% ).

winreg.REG_LINK

Символическая ссылка Unicode.

winreg.REG_MULTI_SZ

Последовательность строк, завершающихся символом null, завершающихся двумя символами null. (Python обрабатывает это завершение automatically.)

winreg.REG_NONE

Нет определенного типа значения.

winreg.REG_QWORD

64-битное число.

Новое в версии 3.6.

winreg.REG_QWORD_LITTLE_ENDIAN

64-битное число в формате с прямым порядком байтов. Эквивалент К14153К.

Новое в версии 3.6.

winreg.REG_RESOURCE_LIST

Список ресурсов драйвера устройства.

winreg.REG_FULL_RESOURCE_DESCRIPTOR

Аппаратная настройка.

winreg.REG_RESOURCE_REQUIREMENTS_LIST

Список аппаратных ресурсов.

winreg.REG_SZ

Строка, завершающаяся null.

Объекты дескриптора реестра

Этот объект оборачивает объект Windows HKEY, автоматически закрывая его при уничтожении объекта. Чтобы гарантировать очистку, вы можете вызвать либо метод Close() объекта, либо функцию CloseKey() .

Все функции реестра в этом модуле возвращают один из этих объектов.

Все функции реестра в этом модуле, которые принимают объект дескриптора, также принимают целое число, однако использование объекта дескриптора приветствуется.

Объекты-дескрипторы обеспечивают семантику для __bool__() – таким образом

if handle:
    print("Yes")

напечатает Yes , если дескриптор в данный момент действителен (не был закрыт или detached).

Объект также поддерживает семантику сравнения, поэтому объекты дескрипторов будут сравнивать true, если они оба ссылаются на одно и то же базовое значение дескриптора Windows.

Объекты-дескрипторы можно преобразовать в целое число (e.g., с помощью встроенного int() function),, и в этом случае возвращается базовое значение дескриптора Windows. Вы также можете использовать метод Detach() для возврата целочисленного дескриптора, а также отключить дескриптор Windows от объекта дескриптора.

PyHKEY.Close()

Закрывает базовый дескриптор Windows.

Если дескриптор уже закрыт, ошибка не возникает.

PyHKEY.Detach()

Отсоединяет дескриптор Windows от объекта дескриптора.

Результатом является целое число, которое содержит значение дескриптора до его отсоединения. Если дескриптор уже отсоединен или закрыт, это вернет ноль.

После вызова этой функции дескриптор фактически становится недействительным, но не закрывается. Вы можете вызвать эту функцию, если вам нужно, чтобы базовый дескриптор Win32 существовал после времени существования объекта дескриптора.

Вызывает auditing event winreg.PyHKEY.Detach с аргументом key .

PyHKEY.__enter__()
PyHKEY.__exit__(*exc_info)

Объект HKEY реализует __enter__() и __exit__() и, таким образом, поддерживает контекстный протокол для оператора with :

with OpenKey(HKEY_LOCAL_MACHINE, "foo") as key:
    ...  # work with key

автоматически закроет ключ, когда управление покинет блок with .

© 2001–2023 Python Software Foundation
Licensed under the PSF License.
https://docs.python.org/3.11/library/winreg.html

Источник

I simplified _winreg functionality for querying a given registry key’s nested values.

For instance, this is how straight-forward it is to query the registry key you asked about:

key = r'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall'

for sub_key in get_sub_keys(key):
    path = join(key, sub_key)
    value = get_values(path, ['DisplayName', 'DisplayVersion', 'InstallDate'])

    if value:
        print value

output

{'DisplayVersion': u'347.25', 'DisplayName': u'NVIDIA Control Panel 347.25', 'InstallDate': u'20150125'}
{'DisplayVersion': u'347.25', 'DisplayName': u'NVIDIA Graphics Driver 347.25', 'InstallDate': u'20150125'}
{'DisplayVersion': u'2.2.2', 'DisplayName': u'NVIDIA GeForce Experience 2.2.2', 'InstallDate': u'20150212'}
...

Add these utility functions as well:

from _winreg import *
import os

roots_hives = {
    "HKEY_CLASSES_ROOT": HKEY_CLASSES_ROOT,
    "HKEY_CURRENT_USER": HKEY_CURRENT_USER,
    "HKEY_LOCAL_MACHINE": HKEY_LOCAL_MACHINE,
    "HKEY_USERS": HKEY_USERS,
    "HKEY_PERFORMANCE_DATA": HKEY_PERFORMANCE_DATA,
    "HKEY_CURRENT_CONFIG": HKEY_CURRENT_CONFIG,
    "HKEY_DYN_DATA": HKEY_DYN_DATA
}

def parse_key(key):
    key = key.upper()
    parts = key.split('\\')
    root_hive_name = parts[0]
    root_hive = roots_hives.get(root_hive_name)
    partial_key = '\\'.join(parts[1:])

    if not root_hive:
        raise Exception('root hive "{}" was not found'.format(root_hive_name))

    return partial_key, root_hive


def get_sub_keys(key):
    partial_key, root_hive = parse_key(key)

    with ConnectRegistry(None, root_hive) as reg:
        with OpenKey(reg, partial_key) as key_object:
            sub_keys_count, values_count, last_modified = QueryInfoKey(key_object)
            try:
                for i in range(sub_keys_count):
                    sub_key_name = EnumKey(key_object, i)
                    yield sub_key_name
            except WindowsError:
                pass


def get_values(key, fields):
    partial_key, root_hive = parse_key(key)

    with ConnectRegistry(None, root_hive) as reg:
        with OpenKey(reg, partial_key) as key_object:
            data = {}
            for field in fields:
                try:
                    value, type = QueryValueEx(key_object, field)
                    data[field] = value
                except WindowsError:
                    pass

            return data


def get_value(key, field):
    values = get_values(key, [field])
    return values.get(field)


def join(path, *paths):
    path = path.strip('/\\')
    paths = map(lambda x: x.strip('/\\'), paths)
    paths = list(paths)
    result = os.path.join(path, *paths)
    result = result.replace('/', '\\')
    return result

Источник

В этой статье мы рассмотрим, как использовать Python для редактирования реестра в операционной системе Windows. Реестр — это центральное хранилище информации о системе и всех установленных программах. Он содержит ключи и значения, которые можно изменять с помощью различных инструментов, включая Python.

Python обеспечивает доступ к реестру с помощью модуля winreg, который входит в стандартную библиотеку. Этот модуль позволяет читать, записывать и удалять ключи и значения реестра.

Первым шагом в использовании модуля winreg является импорт:

import winreg

Далее мы можем открыть определенную ветвь реестра с помощью функции winreg.OpenKey. Функция принимает два аргумента: первый — константу, определяющую ветвь реестра, и второй — строку, содержащую путь к конкретной ветви. Например, чтобы открыть ветвь HKEY_CURRENT_USER, мы можем использовать следующий код:

key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft")

Вместо r»Software\Microsoft» вы можете указать путь к любой другой ветви реестра, с которой хотите работать.

Когда мы открываем ветвь реестра, мы можем читать значения, удалять их или записывать новые. Чтение значения осуществляется с помощью функции winreg.QueryValue, которая принимает два аргумента: первый — объект ключа, второй — строку, содержащую имя значения. Например:

value = winreg.QueryValue(key, "ProgramFilesDir")
print(value)

В данном примере мы читаем значение «ProgramFilesDir» из открытой ранее ветви реестра и выводим его на экран.

Чтобы записать значение в реестр, можно использовать функцию winreg.SetValue, которая принимает четыре аргумента: объект ключа, имя значения, его тип (например, строка, целое число или двоичные данные) и само значение. Например, чтобы записать строковое значение, мы можем использовать следующий код:

winreg.SetValue(key, "NewValue", winreg.REG_SZ, "Hello, World!")

В данном примере мы записываем значение «Hello, World!» с именем «NewValue» в открытую ранее ветвь реестра. winreg.REG_SZ — это константа, которая указывает, что мы записываем строковое значение.

Если вы хотите удалить ключ или значение из реестра, вы можете использовать функции winreg.DeleteKey и winreg.DeleteValue соответственно. Например, чтобы удалить ключ, вы можете использовать следующий код:

winreg.DeleteKey(key, "SubKey")

В данном примере мы удаляем ключ с именем «SubKey» из открытой ранее ветви реестра.

После завершения работы с реестром необходимо закрыть объект ключа с помощью функции winreg.CloseKey:

winreg.CloseKey(key)

В данной статье мы рассмотрели основы редактирования реестра с помощью Python. Модуль winreg предоставляет мощные инструменты для работы с системным реестром в операционной системе Windows. Пользуясь вышеописанными методами, вы можете создавать, изменять и удалять ключи и значения в реестре, что позволяет полностью контролировать системные настройки и поведение программ.

Работа с реестром требует аккуратности, поскольку ошибки могут привести к неправильной работе системы. Поэтому перед внесением изменений в реестр рекомендуется создавать резервные копии или использовать инструменты для системного администрирования.

Источник

Python’s standard library is known for including lots of handy modules and packages that can be used without installing anything else. That’s one of the primary reasons that its standard library is called “batteries included” so often. So it should come as no surprise that Python includes a Windows only module for editing the Windows Registry. This particular module goes by the odd name of _winreg (odd because it starts with an underscore). In this article, we’ll learn the basics of working with the Registry using this “battery”.

Reading from the Registry

Using Python to read data from the registry is very easy. In the following example, we’ll find out where Outlook Express is installed:

from _winreg import *
key = OpenKey(HKEY_LOCAL_MACHINE, r'Software\Microsoft\Outlook Express', 0, KEY_ALL_ACCESS)
QueryValueEx(key, "InstallRoot")

On my machine, this will return the following tuple: (u’%ProgramFiles%\\Outlook Express’, 2). The tuple is made up of the value and the registry type of said value. There are two other query methods that one can use called QueryInfoKey and QueryValue. The former gives you information about the key itself in form of three integers while the latter retrieves only the data for a key’s first value that has a NULL name. The documentation recommends that you use QueryValueEx whenever possible.

We should probably quickly explain what’s going on in the code above as well. The OpenKey function takes an HKEY* constant, a subkey path string, a reserved integer (which must be zero) and the security mask. In this case, we passed in KEY_ALL_ACCESS which gives us complete control of that key. Since all we were doing was reading it, we probably should have just used KEY_READ though. As for what QueryValueEx does, it just accepts a key object and the field name that we want to query against.

Writing to the Registry

If you’ve been reading this blog lately, then you’ve probably already seen the _winreg module used for writing to the registry. This will just be review for you, so feel free to skip this section. We’ll start out with a practical example. In the following code snippet, we will set Internet Explorer’s home page. As always, please note that editing Registry entries can be dangerous. IMPORTANT: Be sure to back up your registry before attempting to edit it. Now, on with the show!

keyVal = r'Software\Microsoft\Internet Explorer\Main'
try:
    key = OpenKey(HKEY_CURRENT_USER, keyVal, 0, KEY_ALL_ACCESS)
except:
    key = CreateKey(HKEY_CURRENT_USER, keyVal)
SetValueEx(key, "Start Page", 0, REG_SZ, "https://www.blog.pythonlibrary.org/")
CloseKey(key)

In the code above, we attempt to open the following key: HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\Main and set the “Start Page” value to this blog. If the open fails, it’s usually because the key doesn’t exist, so we try to create the key in our exception handler. Then we use SetValueEx to actually set the value and like all good programmers, we clean up when we’re done and close the key. If you skipped the CloseKey command, you’d be fine in this case as the script is done and Python will do it for you. However, if you continued working on this key, you might have an access violation since it’s already open. Thus, the lesson is to always close a key when you finish editing it.

Other _winreg Methods

There are several other methods in the _winreg library worth pointing out. The DeleteKey method is handy when you need to remove a key. Unfortunately, I’ve had occasion when I need to remove keys recursively, such as when an uninstall goes bad and _winreg has no built-in way of doing that. You can write your own, of course, or you can download a wrapper like YARW (Yet Another Registry Wrapper) that can do it for you.

DeleteValue is similar to DeleteKey, except that you delete just a value. Yes, it’s pretty obvious. If you’d wanted to write your own recursive key deleting code, then you’d probably want to take a look at EnumKey and EnumValue as they enumerate keys and values respectively. Let’s take a quick look at how to use EnumKey:

from _winreg import EnumKey, HKEY_USERS

try:
    i = 0
    while True:
        subkey = EnumKey(HKEY_USERS, i)
        print subkey
        i += 1
except WindowsError:
    # WindowsError: [Errno 259] No more data is available    
    pass

The code above will loop through the HKEY_USERS hive printing the subkey to stdout until we reach the end of the hive and a WindowsError is raised. Of course, this does not descend into the subkeys, but I’ll leave that as an exercise for the reader to figure out.

The last method that we’ll talk about here is ConnectRegistry. This is helpful if we need to edit the Registry of a remote machine. It only accepts two arguments: the computer name and the key to connect to (i.e. HKEY_LOCAL_MACHINE or some such). Note that when connecting to remote machines, you can only edit certain keys while the others are unavailable.

Wrapping Up

I hope this was helpful for you and that it gave you lots of good ideas for your future projects. I have many login scripts that use this wonderful library and a couple that use YARW. It’s been quite useful so far and I hope that it will be the same for you.

UPDATE (10/14/2011): We now have a Brazilian Portuguese translation of this post up on Carlisson Galdino’s blog

Further Reading

  • Official documentation for _winreg
  • Effbot tutorial on _winreg

Источник

  • Python script run in background windows
  • Python для windows server 2012
  • Python работа с консолью windows
  • Python run command in windows
  • Python для windows 7 service pack 1