Schnittstelle zum ändern von Windows Umgebungsvariablen von Python

Mit setx hat einige Nachteile, vor allem, wenn Sie versuchen, anfügen", um die Umgebungsvariablen (wie zB. setx PATH %Path%;C:\mypath), wird Dieser immer wieder "anfügen", um den Pfad jedes mal, wenn Sie es ausführen, kann ein problem sein. Schlimmer noch, es unterscheidet nicht zwischen der Maschine Weg (gespeichert in HKEY_LOCAL_MACHINE) und den user-Pfad (in HKEY_CURRENT_USER gespeichert). Die Umgebungsvariablen an, die Sie sehen, an einer Eingabeaufforderung aus einer Verkettung dieser beiden Werte. Daher vor dem Aufruf von setx:

user PATH == u
machine PATH == m
%PATH% == m;u

> setx PATH %PATH%;new

Calling setx sets the USER path by default, hence now:
user PATH == m;u;new
machine PATH == m
%PATH% == m;m;u;new

Den system-Pfad ist unvermeidlich dupliziert in der %PATH% - Umgebungsvariable bei jedem Aufruf setx auf an PFAD anfügen. Diese Veränderungen sind dauerhaft, nie zurückgesetzt wird neu gestartet, und so sammeln sich über die Lebensdauer der Maschine.

Versucht, den Ausgleich im DOS ist jenseits meiner Fähigkeit. So wandte ich mich an Python. Die Lösung, die ich habe kommen mit heute, ist das setzen von Umgebungsvariablen durch optimieren der Registrierung, einschließlich Anhängen WEG, ohne dass Duplikate, ist wie folgt:

from os import system, environ
import win32con
from win32gui import SendMessage
from _winreg import (
    CloseKey, OpenKey, QueryValueEx, SetValueEx,
    HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE,
    KEY_ALL_ACCESS, KEY_READ, REG_EXPAND_SZ, REG_SZ
)

def env_keys(user=True):
    if user:
        root = HKEY_CURRENT_USER
        subkey = 'Environment'
    else:
        root = HKEY_LOCAL_MACHINE
        subkey = r'SYSTEM\CurrentControlSet\Control\Session Manager\Environment'
    return root, subkey


def get_env(name, user=True):
    root, subkey = env_keys(user)
    key = OpenKey(root, subkey, 0, KEY_READ)
    try:
        value, _ = QueryValueEx(key, name)
    except WindowsError:
        return ''
    return value


def set_env(name, value):
    key = OpenKey(HKEY_CURRENT_USER, 'Environment', 0, KEY_ALL_ACCESS)
    SetValueEx(key, name, 0, REG_EXPAND_SZ, value)
    CloseKey(key)
    SendMessage(
        win32con.HWND_BROADCAST, win32con.WM_SETTINGCHANGE, 0, 'Environment')


def remove(paths, value):
    while value in paths:
        paths.remove(value)


def unique(paths):
    unique = []
    for value in paths:
        if value not in unique:
            unique.append(value)
    return unique


def prepend_env(name, values):
    for value in values:
        paths = get_env(name).split(';')
        remove(paths, '')
        paths = unique(paths)
        remove(paths, value)
        paths.insert(0, value)
        set_env(name, ';'.join(paths))


def prepend_env_pathext(values):
    prepend_env('PathExt_User', values)
    pathext = ';'.join([
        get_env('PathExt_User'),
        get_env('PathExt', user=False)
    ])
    set_env('PathExt', pathext)



set_env('Home', '%HomeDrive%%HomePath%')
set_env('Docs', '%HomeDrive%%HomePath%\docs')
set_env('Prompt', '$P$_$G$S')

prepend_env('Path', [
    r'%SystemDrive%\cygwin\bin', # Add cygwin binaries to path
    r'%HomeDrive%%HomePath%\bin', # shortcuts and 'pass-through' bat files
    r'%HomeDrive%%HomePath%\docs\bin\mswin', # copies of standalone executables
])

# allow running of these filetypes without having to type the extension
prepend_env_pathext(['.lnk', '.exe.lnk', '.py'])

Es hat keinen Einfluss auf den aktuellen Prozess oder die Eltern-shell, aber es wirkt sich auf alle cmd-Fenster geöffnet, nachdem Sie es ausführen, ohne einen Neustart, und kann problemlos bearbeitet werden und erneut ausführen, viele Male, ohne dass irgendwelche Duplikate.

Es muss ein Jahrtausend her, dass ich versucht habe, die Umgebung ändern des aktuellen DOS-Sitzung mit Hilfe eines Programms. Das problem ist: das Programm läuft in seinem eigenen DOS-shell, so hat es zu funktionieren auf seinem übergeordneten Umwelt. Es dauert ein Spaziergang, beginnend an der die DOS-Info-Block, alle entlang der chain of Memory Control Blocks, um den Speicherort des übergeordneten Umwelt. Einmal hatte ich herausgefunden, wie dies zu tun, mein Bedürfnis nach Manipulation environment-Variablen verschwunden war. Ich gebe Ihnen das Turbo-Pascal-code unten, aber ich denke, es gibt mindestens drei bessere Wege, um den trick zu tun:

1. Erstellen Sie eine batch-Datei: (a) fordert ein Python-script (oder was auch immer) erzeugt temporary batch-Datei mit den entsprechenden SET-Befehle; (b) ruft die temporäre batch-Datei (die SET-Befehle werden ausgeführt in der aktuellen shell); und (c) entfernt die temporäre batch-Datei.

2. Erstellen Sie ein Python Skript, das etwas schreibt wie "VAR1=val1\nVAR2=val2\nVAR3=val3\n") auf STDOUT aus. Diese Art der Nutzung in Ihrem batch-Datei:

   for /f "delims=|" %%X in ('callYourPythonScript') do set %%X

   et voilà: die Variablen VAR1, VAR2 und VAR3 haben schon einen Wert.

3. Die Windows-Registry ändern und die broadcast-Einstellung ändern, wie beschrieben hier von Alexander Prokofyev.

- Und hier geht der Pascal-code (Sie können ein Niederländisches Wörterbuch und ein Pascal-Programmierung Buch) von einem Programm, das einfach Berichte Speicherplätze. Es scheint immer noch zu funktionieren unter Windows XP, werden it-reporting wir laufen DOS 5.00. Dies ist nur ein Erster Anfang, es gibt eine Menge von low-level-Programmierung zu tun, um zu manipulieren, um die ausgewählte Umgebung. Und als der Zeiger-Struktur zu sein scheint, bin ich mir nicht so sicher, ob die Umwelt-Modell von 1994 hält immer noch diese Tage...

program MCBKETEN;
uses dos, HexConv;

{ ---------------------------------------------------------------------------- }
{  Programma: MCBKETEN.EXE                                                   }
{  Broncode : MCBKETEN.PAS                                                   }
{  Doel     : Tocht langs de MCB's met rapportage                            }
{  Datum    : 11 januari 1994                                                }
{  Auteur   : Meindert Meindertsma                                           }
{  Versie   : 1.00                                                           }
{ ---------------------------------------------------------------------------- }

type
   MCB_Ptr     = ^MCB;
{  MCB_PtrPtr  = ^MCB_Ptr;  vervallen wegens DOS 2.11 -- zie verderop }
   MCB         = record
                    Signatuur    : char;
                    Eigenaar     : word;
                    Paragrafen   : word;
                    Gereserveerd : array[1..3] of byte;
                    Naam         : array[1..8] of char;
                 end;
   BlokPtr     = ^BlokRec;
   BlokRec     = record
                    Vorige       : BlokPtr;
                    DitSegment,
                    Paragrafen   : word;
                    Signatuur    : string[6];
                    Eigenaar,
                    Omgeving     : word;
                    Functie      : String4;
                    Oorsprong,
                    Pijl         : char;
                    KorteNaam    : string[8];
                    LangeNaam    : string;
                    Volgende     : BlokPtr;
                 end;
   PSP_Ptr     = ^PSP;
   PSP         = record
                    Vulsel1      : array[1..44] of byte;
                    Omgeving     : word;
                    Vulsel2      : array[47..256] of byte;
                 end;

var
   Zone                  : string[5];
   ProgGevonden,
   EindeKeten,
   Dos3punt2             : boolean;
   Regs                  : registers;
   ActMCB                : MCB_Ptr;
   EersteSchakel, Schakel,
   LaatsteSchakel        : BlokPtr;
   ActPSP                : PSP_Ptr;
   EersteProg,
   Meester, Ouder,
   TerugkeerSegment,
   TerugkeerOffset,
   TerugkeerSegment2,
   OuderSegment          : word;
   Specificatie          : string[8];
   ReleaseNummer         : string[2];
   i                     : byte;


{ ---------------------------------------------------------------------------- }
{  PROCEDURES EN FUNCTIES                                                    }
{ ---------------------------------------------------------------------------- }

function Coda (Omgeving : word; Paragrafen : word) : string;

var
   i            : longint;
   Vorige, Deze : char;
   Streng       : string;

begin
   i    := 0;
   Deze := #0;
   repeat
      Vorige := Deze;
      Deze   := char (ptr (Omgeving, i)^);
      inc (i);
   until ((Vorige = #0) and (Deze = #0)) or (i div $10 >= Paragrafen);
   if (i + 3) div $10 < Paragrafen then begin
      Vorige := char (ptr (Omgeving, i)^);
      inc (i);
      Deze   := char (ptr (Omgeving, i)^);
      inc (i);
      if (Vorige = #01) and (Deze = #0) then begin
         Streng := '';
         Deze   := char (ptr (Omgeving, i)^);
         inc (i);
         while (Deze <> #0) and (i div $10 < Paragrafen) do begin
            Streng := Streng + Deze;
            Deze   := char (ptr (Omgeving, i)^);
            inc (i);
         end;
         Coda := Streng;
      end
      else Coda := '';
   end
   else Coda := '';
end {Coda};


{ ---------------------------------------------------------------------------- }
{  HOOFDPROGRAMMA                                                            }
{ ---------------------------------------------------------------------------- }

BEGIN
  { ----- Initiatie ----- }
   Zone            := 'Lower';
   ProgGevonden    := FALSE;
   EindeKeten      := FALSE;
   Dos3punt2       := (dosversion >= $1403) and (dosversion <= $1D03);
   Meester         := $0000;
   Ouder           := $0000;
   Specificatie[0] := #8;
   str (hi (dosversion) : 2, ReleaseNummer);
   if ReleaseNummer[1] = ' ' then ReleaseNummer[1] := '0';

  { ----- Pointer naar eerste MCB ophalen ------ }
   Regs.AH := $52;  { functie $52 geeft adres van DOS Info Block in ES:BX }
   msdos (Regs);
{  ActMCB := MCB_PtrPtr (ptr (Regs.ES, Regs.BX - 4))^;  NIET onder DOS 2.11  }
   ActMCB := ptr (word (ptr (Regs.ES, Regs.BX - 2)^), $0000);

  { ----- MCB-keten doorlopen ----- }
   new (EersteSchakel);
   EersteSchakel^.Vorige := nil;
   Schakel               := EersteSchakel;
   repeat
      with Schakel^ do begin
         DitSegment := seg (ActMCB^);
         Paragrafen := ActMCB^.Paragrafen;
         if DitSegment + Paragrafen >= $A000 then
            Zone    := 'Upper';
         Signatuur  := Zone + ActMCB^.Signatuur;
         Eigenaar   := ActMCB^.Eigenaar;
         ActPSP     := ptr (Eigenaar, 0);
         if not ProgGevonden then EersteProg := DitSegment + 1;
         if Eigenaar >= EersteProg
            then Omgeving := ActPSP^.Omgeving
            else Omgeving := 0;
         if DitSegment + 1 = Eigenaar then begin
            ProgGevonden  := TRUE;
            Functie       := 'Prog';
            KorteNaam[0]  := #0;
            while (ActMCB^.Naam[ ord (KorteNaam[0]) + 1 ] <> #0) and
                  (KorteNaam[0] < #8) do
            begin
               inc (KorteNaam[0]);
               KorteNaam[ ord (KorteNaam[0]) ] :=
                  ActMCB^.Naam[ ord (KorteNaam[0]) ];
            end;
            if Eigenaar = prefixseg then begin
               TerugkeerSegment := word (ptr (prefixseg, $000C)^);
               TerugkeerOffset  := word (ptr (prefixseg, $000A)^);
               LangeNaam        := '-----> Terminate Vector = '     +
                                   WordHex (TerugkeerSegment) + ':' +
                                   WordHex (TerugkeerOffset )        ;
            end
            else
               LangeNaam := '';
         end {if ÆProgØ}
         else begin
            if Eigenaar = $0008 then begin
               if ActMCB^.Naam[1] = 'S' then
                  case ActMCB^.Naam[2] of
                     'D' : Functie := 'SysD';
                     'C' : Functie := 'SysP';
                     else  Functie := 'Data';
                  end {case}
               else        Functie := 'Data';
               KorteNaam := '';
               LangeNaam := '';
            end {if Eigenaar = $0008}
            else begin
               if DitSegment + 1 = Omgeving then begin
                  Functie   := 'Env ';
                  LangeNaam := Coda (Omgeving, Paragrafen);
                  if EersteProg = Eigenaar then Meester := Omgeving;
               end {if ÆEnvØ}
               else begin
                  move (ptr (DitSegment + 1, 0)^, Specificatie[1], 8);
                  if (Specificatie = 'PATH=' + #0 + 'CO') or
                     (Specificatie = 'COMSPEC='         ) or
                     (Specificatie = 'OS=DRDOS'         ) then
                  begin
                     Functie   := 'Env' + chr (39);
                     LangeNaam := Coda (DitSegment + 1, Paragrafen);
                     if (EersteProg = Eigenaar) and
                        (Meester    = $0000   )
                     then
                        Meester := DitSegment + 1;
                  end
                  else begin
                     if Eigenaar = 0
                        then Functie := 'Free'
                        else Functie := 'Data';
                     LangeNaam := '';
                     if (EersteProg = Eigenaar) and
                        (Meester    = $0000   )
                     then
                        Meester := DitSegment + 1;
                  end;
               end {else: not ÆEnvØ};
               KorteNaam := '';
            end {else: Eigenaar <> $0008};
         end {else: not ÆProgØ};

        { ----- KorteNaam redigeren ----- }
         for i := 1 to length (KorteNaam) do
            if KorteNaam[i] < #32 then KorteNaam[i] := '.';
         KorteNaam := KorteNaam + '        ';

        { ----- Oorsprong vaststellen ----- }
         if EersteProg = Eigenaar
            then Oorsprong := '*'
            else Oorsprong := ' ';

        { ----- Actueel proces (uitgaande Pijl) vaststellen ----- }
         if Eigenaar = prefixseg
            then Pijl := '>'
            else Pijl := ' ';
      end {with Schakel^};

     { ----- MCB-opeenvolging onderzoeken /schakelverloop vaststellen ----- }
      if (Zone = 'Upper') and (ActMCB^.Signatuur = 'Z') then begin
         Schakel^.Volgende := nil;
         EindeKeten        := TRUE;
      end
      else begin
         ActMCB := ptr (seg (ActMCB^) + ActMCB^.Paragrafen + 1, 0);
         if ((ActMCB^.Signatuur <> 'M') and (ActMCB^.Signatuur <> 'Z')) or
            ($FFFF - ActMCB^.Paragrafen < seg (ActMCB^)               )
         then begin
            Schakel^.Volgende := nil;
            EindeKeten        := TRUE;
         end
         else begin
            new (LaatsteSchakel);
            Schakel^.Volgende      := LaatsteSchakel;
            LaatsteSchakel^.Vorige := Schakel;
            Schakel                := LaatsteSchakel;
         end {else: (ÆMØ or ÆZØ) and Æteveel_ParagrafenØ};
      end {else: ÆLowerØ or not ÆZØ};
   until EindeKeten;

  { ----- Terugtocht ----- }
   while Schakel <> nil do with Schakel^ do begin

     { ----- Ouder-proces vaststellen ----- }
      TerugkeerSegment2 := TerugkeerSegment + (TerugkeerOffset div $10);
      if (DitSegment              <= TerugkeerSegment2) and
         (DitSegment + Paragrafen >= TerugkeerSegment2)
      then
         OuderSegment := Eigenaar;

     { ----- Meester-omgeving markeren ----- }
      if DitSegment + 1 = Meester then Oorsprong := 'M';

     { ----- Schakel-verloop ----- }
      Schakel := Schakel^.Vorige;
   end {while Schakel <> nil};

  { ----- Rapportage ----- }
   writeln ('Chain of Memory Control Blocks in DOS version ',
            lo (dosversion), '.', ReleaseNummer, ':');
   writeln;
   writeln ('MCB@ #Par Signat PSP@ Env@ Type !! Name     File');
   writeln ('---- ---- ------ ---- ---- ---- -- -------- ',
            '-----------------------------------');
   Schakel := EersteSchakel;
   while Schakel <> nil do with Schakel^ do begin

     { ----- Ouder-omgeving vaststellen ----- }
      if Eigenaar = OuderSegment then begin
         if not Dos3punt2 then begin
            if (Functie = 'Env ') then begin
               Ouder := DitSegment + 1;
               Pijl  := 'Û';
            end
            else
               Pijl := '<';
         end {if not Dos3punt2}
         else begin
            if ((Functie = 'Env' + chr (39)) or (Functie = 'Data')) and
               (Ouder    = $0000)
            then begin
               Ouder := DitSegment + 1;
               Pijl  := 'Û';
            end
            else
               Pijl := '<';
         end {else: Dos3punt2};
      end {with Schakel^};

     { ----- Keten-weergave ----- }
      writeln (WordHex (DitSegment)        , ' ',
               WordHex (Paragrafen)        , ' ',
               Signatuur                   , ' ',
               WordHex (Eigenaar)          , ' ',
               WordHex (Omgeving)          , ' ',
               Functie                     , ' ',
               Oorsprong, Pijl             , ' ',
               KorteNaam                   , ' ',
               LangeNaam                        );

     { ----- Schakel-verloop ----- }
      Schakel := Schakel^.Volgende;
   end {while Schakel <> nil};

  { ----- Afsluiting rapportage ----- }
   writeln;

   write ('* = First command interpreter at ');
   if ProgGevonden
      then writeln (WordHex (EersteProg), ':0000')
      else writeln ('?');

   write ('M = Master environment        at ');
   if Meester > $0000
      then writeln (WordHex (Meester), ':0000')
      else writeln ('?');

   write ('< = Parent proces             at ');
   writeln (WordHex (OuderSegment), ':0000');

   write ('Û = Parent environment        at ');
   if Ouder > $0000
      then writeln (WordHex (Ouder), ':0000')
      else writeln ('?');

   writeln ('> = Current proces            at ',
            WordHex (prefixseg), ':0000');

   writeln ('    returns                   to ',
            WordHex (TerugkeerSegment), ':', WordHex (TerugkeerOffset));
END.

(Oberhalb von ASCII 127, kann es einige ASCII - /ANSI-übersetzung-Themen in dieser Präsentation.)

In das os-Modul gibt es getenv und putenv Funktionen. Es scheint jedoch, dass die putenv nicht korrekt funktioniert und, dass Sie müssen verwenden Sie die windows-registry statt

Blick auf diese Diskussion