`sys` — Systemspecifika parametrar och funktioner¶

Denna modul ger tillgång till vissa variabler som används eller underhålls av tolken och till funktioner som interagerar starkt med tolken. Den är alltid tillgänglig. Om inte annat uttryckligen anges är alla variabler skrivskyddade.

sys.abiflags¶: På POSIX-system där Python byggdes med standardskriptet configure innehåller detta ABI-flaggorna som anges av PEP 3149.

Tillagd i version 3.2.

Ändrad i version 3.8: Standardflaggorna blev en tom sträng (m-flaggan för pymalloc har tagits bort).

Tillgänglighet: Unix.

sys.addaudithook(hook)¶

Lägg till den anropsbara hook till listan över aktiva revisionskrokar för den aktuella (under)tolken.

När en granskningshändelse utlöses genom funktionen sys.audit() kommer varje hook att anropas i den ordning den lades till med händelsens namn och tupeln av argument. Inhemska hooks som lagts till av PySys_AddAuditHook() anropas först, följt av hooks som lagts till i den aktuella (under)tolken. Hooks kan sedan logga händelsen, skapa ett undantag för att avbryta operationen eller avsluta processen helt och hållet.

Observera att audit hooks främst är till för att samla in information om interna eller på annat sätt icke observerbara åtgärder, oavsett om de utförs av Python eller bibliotek skrivna i Python. De är inte lämpliga för att implementera en ”sandlåda”. I synnerhet kan skadlig kod trivialt inaktivera eller kringgå hooks som läggs till med denna funktion. Som ett minimum måste alla säkerhetskänsliga hooks läggas till med hjälp av C API PySys_AddAuditHook() innan körtiden initialiseras, och alla moduler som tillåter godtycklig minnesmodifiering (t.ex. ctypes) bör tas bort helt eller övervakas noga.

Anrop av sys.addaudithook() kommer i sig att skapa en granskningshändelse med namnet sys.addaudithook utan argument. Om någon befintlig hook ger upphov till ett undantag som härrör från RuntimeError, kommer den nya hooken inte att läggas till och undantaget kommer att undertryckas. Följaktligen kan anropare inte anta att deras hook har lagts till om de inte kontrollerar alla befintliga hooks.

Se audit events table för alla händelser som tagits upp av CPython, och PEP 578 för den ursprungliga designdiskussionen.

Tillagd i version 3.8.

Ändrad i version 3.8.1: Undantag som härrör från Exception men inte från RuntimeError undertrycks inte längre.

När spårning är aktiverat (se settrace()), spåras Python-hooks endast om den anropsbara har en __cantrace__-medlem som är satt till ett sant värde. Annars kommer spårningsfunktioner att hoppa över hooken.

sys.argv¶

Listan med kommandoradsargument som skickas till ett Python-skript. argv[0] är skriptnamnet (det beror på operativsystemet om det är ett fullständigt sökvägsnamn eller inte). Om kommandot utfördes med kommandoradsalternativet -c till tolken, sätts argv[0] till strängen '-c'. Om inget skriptnamn skickades till Python-tolken är argv[0] den tomma strängen.

För att loopa över standardinmatningen eller listan med filer som anges på kommandoraden, se modulen fileinput.

Se även sys.orig_argv.

Anteckning

På Unix skickas kommandoradsargument med byte från operativsystemet. Python avkodar dem med filsystemkodning och felhanteraren ”surrogateescape”. När du behöver originalbytes kan du få det genom [os.fsencode(arg) for arg in sys.argv].

sys.audit(event, *args)¶

Utlöser en granskningshändelse och aktiverar eventuella aktiva gransknings-hooks. event är en sträng som identifierar händelsen och args kan innehålla valfria argument med mer information om händelsen. Antalet och typerna av argument för en viss händelse betraktas som ett offentligt och stabilt API och bör inte ändras mellan releaser.

En granskningshändelse heter till exempel os.chdir. Denna händelse har ett argument som heter path som innehåller den begärda nya arbetskatalogen.

sys.audit() anropar de befintliga revisionskrokarna, skickar händelsens namn och argument, och gör om det första undantaget från någon hook. I allmänhet gäller att om ett undantag uppstår ska det inte hanteras och processen ska avslutas så snabbt som möjligt. Detta gör det möjligt för krokimplementationer att bestämma hur de ska reagera på särskilda händelser: de kan bara logga händelsen eller avbryta operationen genom att lyfta ett undantag.

Hooks läggs till med hjälp av funktionerna sys.addaudithook() eller PySys_AddAuditHook().

Den ursprungliga motsvarigheten till denna funktion är PySys_Audit(). Att använda den ursprungliga funktionen är att föredra när det är möjligt.

Se audit events table för alla händelser som CPython har orsakat.

Tillagd i version 3.8.

sys.base_exec_prefix¶

Motsvarar exec_prefix, men hänvisar till basinstallationen av Python.

När du kör under Virtuella miljöer skrivs exec_prefix över till prefixet för den virtuella miljön. base_exec_prefix ändras däremot inte och pekar alltid på basinstallationen av Python. Se Virtuella miljöer för mer information.

Tillagd i version 3.3.

sys.base_prefix¶

Motsvarar prefix, men hänvisar till basinstallationen av Python.

När du kör under virtuell miljö, skrivs prefix över till prefixet för den virtuella miljön. base_prefix ändras däremot inte och pekar alltid på Python-basinstallationen. Se Virtuella miljöer för mer information.

Tillagd i version 3.3.

sys.byteorder¶: En indikator på den ursprungliga byteordningen. Detta kommer att ha värdet 'big' på big-endian (mest betydelsefulla byte först) plattformar, och 'little' på little-endian (minst betydelsefulla byte först) plattformar.

sys.builtin_module_names¶

En tupel av strängar som innehåller namnen på alla moduler som är kompilerade till denna Python-tolk. (Denna information är inte tillgänglig på något annat sätt — modules.keys() listar bara de importerade modulerna)

Se även listan sys.stdlib_module_names.

sys.call_tracing(func, args)¶

Anropa func(*args), medan spårning är aktiverad. Spårningstillståndet sparas och återställs efteråt. Detta är avsett att anropas från en debugger från en kontrollpunkt, för att rekursivt debugga eller profilera annan kod.

Spårningen avbryts när du anropar en spårningsfunktion som ställts in av settrace() eller setprofile() för att undvika oändlig rekursion. call_tracing() aktiverar explicit rekursion av spårningsfunktionen.

sys.copyright¶: En sträng som innehåller den upphovsrätt som gäller för Python-tolken.

sys._clear_type_cache()¶

Rensa den interna typcachen. Typcachen används för att påskynda uppslagningar av attribut och metoder. Använd funktionen endast för att ta bort onödiga referenser vid felsökning av referensläckor.

Denna funktion bör endast användas för interna och specialiserade ändamål.

Föråldrad sedan version 3.13: Använd istället den mer generella funktionen _clear_internal_caches().

sys._clear_internal_caches()¶: Rensa alla interna prestandarelaterade cacheminnen. Använd denna funktion endast för att frigöra onödiga referenser och minnesblock när du letar efter läckor.

Tillagd i version 3.13.

sys._current_frames()¶

Returnerar en ordbok som mappar varje tråds identifierare till den översta stackram som är aktiv i den tråden när funktionen anropas. Observera att funktioner i modulen traceback kan bygga anropsstacken med hjälp av en sådan ram.

Detta är mest användbart för felsökning av dödlåsning: funktionen kräver inte att de dödlåsta trådarna samarbetar, och dessa trådars anropsstaplar fryses så länge de är dödlåsta. Den ram som returneras för en icke-dödlåst tråd kanske inte har något samband med den trådens aktuella aktivitet när den anropande koden undersöker ramen.

Denna funktion bör endast användas för interna och specialiserade ändamål.

Utlöser en auditing event sys._current_frames utan argument.

sys._current_exceptions()¶

Returnerar en ordbok som mappar varje tråds identifierare till det översta undantaget som för närvarande är aktivt i den tråden när funktionen anropas. Om en tråd inte hanterar ett undantag för närvarande ingår den inte i resultatordlistan.

Detta är mest användbart för statistisk profilering.

Denna funktion bör endast användas för interna och specialiserade ändamål.

Utlöser en auditing event sys._current_exceptions utan argument.

Ändrad i version 3.12: Varje värde i ordlistan är nu en enda undantagsinstans, snarare än en 3-tupel som returneras från sys.exc_info().

sys.breakpointhook()¶

Denna hook-funktion anropas av den inbyggda breakpoint(). Som standard hamnar du i pdb-felsökaren, men den kan ställas in på vilken annan funktion som helst så att du kan välja vilken felsökare som ska användas.

Signaturen för denna funktion är beroende av vad den anropar. Till exempel förväntar sig standardbindningen (t.ex. pdb.set_trace()) inga argument, men du kan binda den till en funktion som förväntar sig ytterligare argument (positionella och/eller nyckelord). Den inbyggda funktionen breakpoint() skickar sina *args och **kws rakt igenom. Vad än breakpointhooks() returnerar returneras från breakpoint().

Standardimplementeringen konsulterar först miljövariabeln PYTHONBREAKPOINT. Om den är satt till "0" så returnerar denna funktion omedelbart, dvs. det är en no-op. Om miljövariabeln inte är inställd, eller är inställd på den tomma strängen, anropas pdb.set_trace(). Annars bör denna variabel namnge en funktion som ska köras, med hjälp av Pythons nomenklatur för prickad import, t.ex. package.subpackage.module.function. I det här fallet skulle package.subpackage.module importeras och den resulterande modulen måste ha en callable med namnet function(). Detta körs, med *args och **kws, och vad än function() returnerar, returnerar sys.breakpointhook() till den inbyggda breakpoint()-funktionen.

Observera att om något går fel när du importerar den anropsbarhet som anges av PYTHONBREAKPOINT, rapporteras en RuntimeWarning och brytpunkten ignoreras.

Observera också att om sys.breakpointhook() åsidosätts programmatiskt, kommer PYTHONBREAKPOINT inte att konsulteras.

Tillagd i version 3.7.

sys._debugmallocstats()¶

Skriv ut lågnivåinformation till stderr om tillståndet för CPythons minnesallokator.

Om Python är byggd i debugläge (configure --with-pydebug option), utför den också några dyra interna konsistenskontroller.

Tillagd i version 3.3.

Denna funktion är specifik för CPython. Det exakta utdataformatet definieras inte här och kan komma att ändras.

sys.dllhandle¶: Heltal som anger handtaget för Python DLL.

Tillgänglighet: Windows.

sys.displayhook(value)¶

Om värde inte är None, skriver denna funktion ut repr(value) till sys.stdout, och sparar värde i builtins._. Om repr(value) inte kan kodas till sys.stdout.encoding med sys.stdout.errors felhanterare (som förmodligen är 'strict'), kodas det till sys.stdout.encoding med 'backslashreplace' felhanterare.

sys.displayhook anropas vid resultatet av utvärderingen av en expression som angetts i en interaktiv Python-session. Visningen av dessa värden kan anpassas genom att tilldela en annan funktion med ett argument till sys.displayhook.

Pseudokod:

def displayhook(värde):
    om värdet är None:
        retur
    # Sätt '_' till None för att undvika rekursion
    builtins._ = Ingen
    text = repr(värde)
    försök:
        sys.stdout.write(text)
    except UnicodeEncodeError:
        bytes = text.encode(sys.stdout.encoding, 'backslashreplace')
        if hasattr(sys.stdout, 'buffer'):
            sys.stdout.buffer.write(bytes)
        else:
            text = bytes.decode(sys.stdout.encoding, 'strict')
            sys.stdout.write(text)
    sys.stdout.write("\n")
    inbyggda._ = värde

Ändrad i version 3.2: Använd felhanteraren 'backslashreplace' på UnicodeEncodeError.

sys.dont_write_bytecode¶: Om detta är sant kommer Python inte att försöka skriva .pyc-filer vid import av källmoduler. Detta värde är initialt inställt på True eller False beroende på kommandoradsalternativet -B och miljövariabeln PYTHONDONTWRITEBYTECODE, men du kan ställa in det själv för att kontrollera generering av bytecode-filer.

sys._emscripten_info¶

En named tuple som innehåller information om miljön på wasm32-emscripten-plattformen. Den namngivna tupeln är preliminär och kan komma att ändras i framtiden.

_emscripten_info.emscripten_version¶: Emscripten-version som tupel av ints (major, minor, micro), t.ex. (3, 1, 8).

_emscripten_info.runtime¶: Körtidssträng, t.ex. webbläsarens användaragent, 'Node.js v14.18.2' eller 'UNKNOWN'.

_emscripten_info.pthreads¶: True om Python är kompilerat med Emscriptens stöd för pthreads.

_emscripten_info.shared_memory¶: True om Python är kompilerad med stöd för delat minne.

Tillgänglighet: Emscripten.

Tillagd i version 3.11.

sys.pycache_prefix¶

Om detta är inställt (inte None), kommer Python att skriva bytecode-cache .pyc-filer till (och läsa dem från) ett parallellt katalogträd med rot i denna katalog, snarare än från __pycache__-kataloger i källkodsträdet. Alla __pycache__-kataloger i källkodsträdet kommer att ignoreras och nya .pyc-filer skrivs inom pycache-prefixet. Om du använder compileall som ett förbyggnadssteg måste du alltså se till att du kör det med samma pycache-prefix (om något) som du kommer att använda vid körning.

En relativ sökväg tolkas i förhållande till den aktuella arbetskatalogen.

Detta värde ställs in initialt baserat på värdet för kommandoradsalternativet -X pycache_prefix=PATH eller miljövariabeln PYTHONPYCACHEPREFIX (kommandoraden har företräde). Om ingen av dem är inställd är den None.

Tillagd i version 3.8.

sys.excepthook(type, value, traceback)¶

Denna funktion skriver ut en given traceback och ett undantag till sys.stderr.

När ett annat undantag än SystemExit uppstår och inte fångas upp, anropar tolken sys.excepthook med tre argument, undantagsklassen, undantagsinstansen och ett spårningsobjekt. I en interaktiv session sker detta precis innan kontrollen återgår till prompten; i ett Python-program sker detta precis innan programmet avslutas. Hanteringen av sådana undantag på högsta nivå kan anpassas genom att tilldela en annan funktion med tre argument till sys.excepthook.

Skapa en granskningshändelse sys.excepthook med argumenten hook, type, value, traceback när ett oavhandlat undantag inträffar. Om ingen hook har ställts in kan hook vara None. Om någon hook skapar ett undantag som härrör från RuntimeError kommer anropet till hooken att undertryckas. I annat fall rapporteras revisions-hook-undantaget som omöjligt att generera och sys.excepthook anropas.

Se även

Funktionen sys.unraisablehook() hanterar undantag som inte kan bedömas och funktionen threading.excepthook() hanterar undantag som orsakas av threading.Thread.run().

sys.__breakpointhook__¶
sys.__displayhook__¶
sys.__excepthook__¶
sys.__unraisablehook__¶: Dessa objekt innehåller originalvärdena för breakpointhook, displayhook, excepthook och unraisablehook i början av programmet. De sparas så att breakpointhook, displayhook och excepthook, unraisablehook kan återställas om de skulle råka ersättas med trasiga eller alternativa objekt.

Tillagd i version 3.7: __breakpointhook__

Tillagd i version 3.8: oanvändbar hook

sys.exception()¶

När denna funktion anropas medan en undantagshanterare körs (t.ex. en except- eller except*-sats) returneras den undantagsinstans som fångades upp av denna hanterare. När undantagshanterare är nästlade i varandra är det bara det undantag som hanteras av den innersta hanteraren som är åtkomligt.

Om ingen undantagshanterare körs, returnerar denna funktion None.

Tillagd i version 3.11.

sys.exc_info()¶

Denna funktion returnerar den gamla stilens representation av det hanterade undantaget. Om ett undantag e för närvarande hanteras (så att exception() skulle returnera e), returnerar exc_info() tupeln (type(e), e, e.__traceback__). Det vill säga en tupel som innehåller typen av undantag (en underklass av BaseException), undantaget i sig och ett traceback-objekt som vanligtvis kapslar in anropsstacken vid den punkt där undantaget senast inträffade.

Om inget undantag hanteras någonstans på stacken, returnerar denna funktion en tupel som innehåller tre None-värden.

Ändrad i version 3.11: Fälten type och traceback härleds nu från value (undantagsinstansen), så när ett undantag ändras medan det hanteras återspeglas ändringarna i resultaten av efterföljande anrop till exc_info().

sys.exec_prefix¶: En sträng som anger det platsspecifika katalogprefix där de plattformsberoende Python-filerna installeras; som standard är detta också '/usr/local'. Detta kan ställas in vid byggtiden med argumentet \--exec-prefix till skriptet configure. Specifikt installeras alla konfigurationsfiler (t.ex. huvudfilen pyconfig.h) i katalogen exec_prefix/lib/pythonX.Y/config, och delade biblioteksmoduler installeras i exec_prefix/lib/pythonX.Y/lib-dynload, där X.Y är versionsnumret för Python, t.ex. 3.2.

Anteckning

Om en virtuell miljö är i kraft kommer detta exec_prefix att peka på den virtuella miljön. Värdet för Python-installationen kommer fortfarande att vara tillgängligt via base_exec_prefix. Se Virtuella miljöer för mer information.

Ändrad i version 3.14: Vid körning under en virtuell miljö, sätts nu prefix och exec_prefix till prefixet för den virtuella miljön av path initialization, istället för site. Detta innebär att prefix och exec_prefix alltid pekar på den virtuella miljön, även när site är inaktiverat (-S).

sys.executable¶: En sträng som anger den absoluta sökvägen till den körbara binärfilen för Python-tolken, på system där detta är meningsfullt. Om Python inte kan hämta den verkliga sökvägen till sin exekverbara fil, kommer sys.executable att vara en tom sträng eller None.

sys.exit([arg])¶

Utlöser ett SystemExit-undantag, som signalerar en avsikt att avsluta tolken.

Det valfria argumentet arg kan vara ett heltal som anger avslutningsstatus (standard är noll) eller en annan typ av objekt. Om det är ett heltal betraktas noll som ”lyckad avslutning” och alla värden som inte är noll betraktas som ”onormal avslutning” av skal och liknande. De flesta system kräver att det ligger i intervallet 0–127 och ger odefinierade resultat annars. Vissa system har en konvention för att tilldela specifika betydelser till specifika utgångskoder, men dessa är i allmänhet underutvecklade; Unix-program använder i allmänhet 2 för syntaxfel på kommandoraden och 1 för alla andra typer av fel. Om en annan typ av objekt skickas, är None likvärdigt med att skicka noll, och alla andra objekt skrivs ut till stderr och resulterar i en utgångskod på 1. I synnerhet är sys.exit("some error message") ett snabbt sätt att avsluta ett program när ett fel inträffar.

Eftersom exit() i slutändan ”bara” ger upphov till ett undantag, kommer den bara att avsluta processen när den anropas från huvudtråden, och undantaget fångas inte upp. Rensningsåtgärder som specificeras av finally-klausuler i try-satser respekteras, och det är möjligt att fånga upp avslutningsförsöket på en yttre nivå.

Ändrad i version 3.6: Om ett fel inträffar i upprensningen efter att Python-tolken har fångat SystemExit (t.ex. ett fel vid rensning av buffrade data i standardströmmarna), ändras utgångsstatus till 120.

sys.flags¶

named tuple flags visar status för kommandoradsflaggor. Flaggor bör endast nås via namn och inte via index. Attributen är skrivskyddade.

flags.debug¶	`-d`
flags.inspect¶	`-i`
flags.interactive¶	`-i`
flags.isolated¶	`-I`
flags.optimize¶	`-O` eller `-OO`
flags.dont_write_bytecode¶	`-B`
flags.no_user_site¶	`-s`
flags.no_site¶	`-S`
flags.ignore_environment¶	`-E`
flags.verbose¶	`-v`
flags.bytes_warning¶	`-b`
flags.quiet¶	`-q`
flags.hash_randomization¶	`-R`
flags.dev_mode¶	`-X dev` (Python Development Mode )
flags.utf8_mode¶	`-X utf8`
flags.safe_path¶	`-P`
flags.int_max_str_digits¶	`-X int_max_str_digits` (begränsning av längd vid konvertering av heltalssträngar)
flags.warn_default_encoding¶	`-X warn_default_encoding`
flags.gil¶	`-X gil` och `PYTHON_GIL`
flags.thread_inherit_context¶	`-X thread_inherit_context` och `PYTHON_THREAD_INHERIT_CONTEXT`
flags.context_aware_warnings¶	`-X context_aware_warnings` och `PYTHON_CONTEXT_AWARE_WARNINGS`

Ändrad i version 3.2: Lagt till attributet quiet för den nya flaggan -q.

Tillagd i version 3.2.3: Attributet hash_randomization.

Ändrad i version 3.3: Borttaget föråldrat attribut division_warning.

Ändrad i version 3.4: Lagt till attributet isolated för flaggan -I isolated.

Ändrad i version 3.7: Lade till attributet dev_mode för den nya Python Development Mode och attributet utf8_mode för den nya -X utf8 flaggan.

Ändrad i version 3.10: Lagt till attributet warn_default_encoding för -X flaggan warn_default_encoding.

Ändrad i version 3.11: Lagt till attributet safe_path för -P option.

Ändrad i version 3.11: Lagt till attributet int_max_str_digits.

Ändrad i version 3.13: Lagt till attributet gil.

Ändrad i version 3.14: Lagt till attributet thread_inherit_context.

Ändrad i version 3.14: Lagt till attributet context_aware_warnings.

sys.float_info¶

En named tuple som innehåller information om float-typen. Den innehåller lågnivåinformation om precisionen och den interna representationen. Värdena motsvarar de olika flyttalskonstanter som definieras i standardhuvudfilen float.h för programmeringsspråket ’C’; se avsnitt 5.2.4.2.2 i 1999 års ISO/IEC C-standard [C99], ’Characteristics of floating types’, för detaljer.

Attribut för `float_info` named tuple¶
attribut	float.h makro	förklaring
float_info.epsilon¶	`DBL_EPSILON`	skillnaden mellan 1,0 och det minsta värde som är större än 1,0 och som kan representeras som en float. Se även `math.ulp()`.
float_info.dig¶	`DBL_DIG`	Det maximala antalet decimaler som kan representeras på ett korrekt sätt i en float; se nedan.
float_info.mant_dig¶	`DBL_MANT_DIG`	Floatprecision: antalet bas-`radix` siffror i signifikanten för en float.
float_info.max¶	`DBL_MAX`	Den maximalt representerbara positiva finita floaten.
float_info.max_exp¶	`DBL_MAX_EXP`	Det maximala heltalet e så att `radix**(e-1)` är en representerbar ändlig float.
float_info.max_10_exp¶	`DBL_MAX_10_EXP`	Det maximala heltalet e så att `10**e` ligger inom intervallet för representerbara finita flyttal.
float_info.min¶	`DBL_MIN`	Den minsta representativa positiva normaliserade floaten. Använd `math.ulp(0.0)` för att få den minsta positiva denormaliserade representerbara flottören.
float_info.min_exp¶	`DBL_MIN_EXP`	Det minsta heltalet e som gör att `radix**(e-1)` är ett normaliserat flyttal.
float_info.min_10_exp¶	`DBL_MIN_10_EXP`	Det minsta heltalet e som gör att `10**e` är ett normaliserat flyttal.
float_info.radix¶	`FLT_RADIX`	Radix för representation av exponent.
float_info.rounds¶	`FLT_ROUNDS`	Ett heltal som representerar avrundningsläget för aritmetik med flyttal. Detta återspeglar värdet på systemets `FLT_ROUNDS`-makro vid tolkens starttidpunkt: `\-1`: obestämbar `0`: mot noll `1`: till närmaste `2`: mot positiv oändlighet `3`: mot negativ oändlighet Alla andra värden för `FLT_ROUNDS` karakteriserar implementationsdefinierat avrundningsbeteende.

Attributet sys.float_info.dig behöver ytterligare förklaring. Om s är en sträng som representerar ett decimaltal med högst sys.float_info.dig signifikanta siffror, kommer konvertering av s till ett float-tal och tillbaka igen att återställa en sträng som representerar samma decimaltal:

>>> import sys
>>> sys.float_info.dig
15
>>> s = '3.14159265358979'    # decimal string with 15 significant digits
>>> format(float(s), '.15g')  # convert to float and back -> same value
'3.14159265358979'

Men för strängar med fler än sys.float_info.dig signifikanta siffror är detta inte alltid sant:

>>> s = '9876543211234567'    # 16 significant digits is too many!
>>> format(float(s), '.16g')  # conversion changes value
'9876543211234568'

sys.float_repr_style¶: En sträng som anger hur funktionen repr() beter sig för float. Om strängen har värdet 'short' så ska repr(x) för en ändlig float x producera en kort sträng med egenskapen att float(repr(x)) == x. Detta är det vanliga beteendet i Python 3.1 och senare. Annars har float_repr_style värdet 'legacy' och repr(x) beter sig på samma sätt som det gjorde i versioner av Python före 3.1.

Tillagd i version 3.1.

sys.getallocatedblocks()¶

Returnerar antalet minnesblock som för närvarande allokeras av tolken, oavsett storlek. Denna funktion är främst användbar för att spåra och felsöka minnesläckor. På grund av tolkens interna cacheminnen kan resultatet variera från anrop till anrop; du kan behöva anropa _clear_internal_caches() och gc.collect() för att få mer förutsägbara resultat.

Om en Python-byggnad eller implementering inte rimligen kan beräkna denna information, får getallocatedblocks() returnera 0 istället.

Tillagd i version 3.4.

sys.getunicodeinternedsize()¶: Returnerar antalet unicode-objekt som har internaliserats.

Tillagd i version 3.12.

sys.getandroidapilevel()¶: Returnerar API-nivån för Android under byggtiden som ett heltal. Detta representerar den minsta versionen av Android som den här versionen av Python kan köras på. För information om körtidsversion, se platform.android_ver().

Tillgänglighet: Android.

Tillagd i version 3.7.

sys.getdefaultencoding()¶: Returnerar 'utf-8'. Detta är namnet på standardkodningen för strängar, som används i metoder som str.encode().

sys.getdlopenflags()¶: Returnerar det aktuella värdet för de flaggor som används för dlopen()-anrop. Symboliska namn för flaggvärdena finns i modulen os (RTLD_xxx-konstanter, t.ex. os.RTLD_LAZY).

Tillgänglighet: Unix.

sys.getfilesystemencoding()¶

Hämta filsystemskodning: den kodning som används med filsystem error handler för att konvertera mellan Unicode-filnamn och bytes-filnamn. Filsystemets felhanterare returneras från getfilesystemencodeerrors().

För bästa kompatibilitet bör str användas för filnamn i samtliga fall, även om det också finns stöd för att representera filnamn som bytes. Funktioner som tar emot eller returnerar filnamn bör stödja antingen str eller bytes och internt konvertera till den representation som systemet föredrar.

os.fsencode() och os.fsdecode() bör användas för att säkerställa att rätt kodning och felmodus används.

filesystem encoding and error handler konfigureras vid Python-start av funktionen PyConfig_Read(): se filesystem_encoding och filesystem_errors i PyConfig.

Ändrad i version 3.2: getfilesystemencoding() resultat kan inte vara None längre.

Ändrad i version 3.6: Windows är inte längre garanterat att returnera 'mbcs'. Se PEP 529 och _enablelegacywindowsfsencoding() för mer information.

Ändrad i version 3.7: Returnerar 'utf-8' om Python UTF-8 Mode är aktiverat.

sys.getfilesystemencodeerrors()¶

Hämta filsystemets felhanterare: den felhanterare som används med filsystemets kodning för att konvertera mellan Unicode-filnamn och bytes-filnamn. Filsystemets kodning returneras från getfilesystemencoding().

os.fsencode() och os.fsdecode() bör användas för att säkerställa att rätt kodning och felmodus används.

filesystem encoding and error handler konfigureras vid Python-start av funktionen PyConfig_Read(): se filesystem_encoding och filesystem_errors i PyConfig.

Tillagd i version 3.6.

sys.get_int_max_str_digits()¶: Returnerar det aktuella värdet för integer string conversion length limitation. Se även set_int_max_str_digits().

Tillagd i version 3.11.

sys.getrefcount(object)¶

Returnerar referensantalet för objektet. Det antal som returneras är i allmänhet ett högre än vad du kan förvänta dig, eftersom det inkluderar den (tillfälliga) referensen som ett argument till getrefcount().

Observera att det returnerade värdet kanske inte återspeglar hur många referenser till objektet som faktiskt finns. Vissa objekt är t.ex. immortal och har ett mycket högt refcount som inte återspeglar det faktiska antalet referenser. Förlita dig därför inte på att det returnerade värdet är korrekt, annat än ett värde på 0 eller 1.

Immortal objekt med ett stort antal referenser kan identifieras via _is_immortal().

Ändrad i version 3.12: Odödliga objekt har mycket stora refcounts som inte stämmer överens med det faktiska antalet referenser till objektet.

sys.getrecursionlimit()¶: Returnerar det aktuella värdet för rekursionsgränsen, det maximala djupet på Python-tolkens stack. Denna gräns förhindrar att oändlig rekursion orsakar ett överflöd av C-stacken och kraschar Python. Den kan ställas in med setrecursionlimit().

sys.getsizeof(object[, default])¶

Returnerar storleken på ett objekt i bytes. Objektet kan vara vilken typ av objekt som helst. Alla inbyggda objekt kommer att returnera korrekta resultat, men detta behöver inte gälla för tredjepartstillägg eftersom det är implementationsspecifikt.

Endast den minnesförbrukning som är direkt hänförlig till objektet redovisas, inte minnesförbrukningen för de objekt som det hänvisar till.

Om den anges kommer default att returneras om objektet inte tillhandahåller något sätt att hämta storleken. Annars kommer ett TypeError att returneras.

getsizeof() anropar objektets __sizeof__-metod och lägger till ytterligare en sopsamlarfunktion om objektet hanteras av sopsamlaren.

Se recursive sizeof recipe för ett exempel på hur man använder getsizeof() rekursivt för att ta reda på storleken på behållare och allt deras innehåll.

sys.getswitchinterval()¶: Returnerar tolkens ”trådbytesintervall” i sekunder; se setswitchinterval().

Tillagd i version 3.2.

sys._getframe([depth])¶

Returnerar ett ramobjekt från anropsstacken. Om det valfria heltalet depth anges, returneras ramobjektet så många anrop under toppen av stacken. Om det är djupare än anropsstacken, kommer ValueError att uppstå. Standardvärdet för depth är noll, vilket returnerar ramen högst upp i anropsstacken.

Utlöser en auditing event sys._getframe med argumentet frame.

Denna funktion bör endast användas för interna och specialiserade ändamål. Det är inte garanterat att den finns i alla implementationer av Python.

sys._getframemodulename([depth])¶

Returnerar namnet på en modul från anropsstacken. Om det valfria heltalet depth anges, returneras modulen så många anrop under toppen av stacken. Om detta är djupare än anropsstacken, eller om modulen inte kan identifieras, returneras None. Standardvärdet för depth är noll, vilket returnerar modulen högst upp i anropsstacken.

Utlöser en auditing event sys._getframemodulename med argumentet depth.

Denna funktion bör endast användas för interna och specialiserade ändamål. Det är inte garanterat att den finns i alla implementationer av Python.

Tillagd i version 3.12.

sys.getobjects(limit[, type])¶

Den här funktionen finns bara om CPython byggdes med det specialiserade configure-alternativet --with-trace-refs. Den är endast avsedd för felsökning av problem med garbage-collection.

Returnerar en lista med upp till limit dynamiskt allokerade Python-objekt. Om type anges inkluderas endast objekt av den exakta typen (inte subtyper).

Objekt från listan är inte säkra att använda. I synnerhet kommer resultatet att innehålla objekt från alla tolkar som delar sitt objektallokeringstillstånd (det vill säga de som skapats med PyInterpreterConfig.use_main_obmalloc satt till 1 eller med Py_NewInterpreter(), och main interpreter). Att blanda objekt från olika tolkar kan leda till krascher eller annat oväntat beteende.

Denna funktion bör endast användas för specialiserade ändamål. Det är inte garanterat att den finns i alla implementationer av Python.

Ändrad i version 3.14: Resultatet kan innehålla objekt från andra tolkar.

sys.getprofile()¶: Hämta den profileringsfunktion som ställts in av setprofile().

sys.gettrace()¶: Hämta spårningsfunktionen som den ställts in av settrace().

Funktionen gettrace() är endast avsedd för implementering av debuggar, profilerare, täckningsverktyg och liknande. Dess beteende är en del av implementeringsplattformen, snarare än en del av språkdefinitionen, och är därför kanske inte tillgänglig i alla Python-implementeringar.

sys.getwindowsversion()¶

Returnerar en namngiven tupel som beskriver den Windows-version som körs för närvarande. De namngivna elementen är major, minor, build, platform, service_pack, service_pack_minor, service_pack_major, suite_mask, product_type och platform_version. service_pack innehåller en sträng, platform_version en 3-tupel och alla andra värden är heltal. Komponenterna kan också nås via namn, så sys.getwindowsversion()[0] är likvärdigt med sys.getwindowsversion().major. För kompatibilitet med tidigare versioner kan endast de första 5 elementen hämtas genom indexering.

plattform kommer att vara 2 (VER_PLATFORM_WIN32_NT).

product_type kan vara ett av följande värden:

Konstant	Betydelse
`1` (VER_NT_WORKSTATION)	Systemet är en arbetsstation.
`2` (VER_NT_DOMAIN_CONTROLLER)	Systemet är en domänkontrollant.
`3` (VER_NT_SERVER)	Systemet är en server, men inte en domänkontrollant.

Denna funktion omsluter Win32-funktionen GetVersionEx(); se Microsoft-dokumentationen för OSVERSIONINFOEX() för mer information om dessa fält.

platform_version returnerar major-versionen, minor-versionen och build-numret för det aktuella operativsystemet, i stället för den version som emuleras för processen. Den är avsedd att användas för loggning snarare än för funktionsdetektering.

Anteckning

platform_version härleder versionen från kernel32.dll som kan vara av en annan version än OS-versionen. Använd modulen platform för att få en korrekt OS-version.

Tillgänglighet: Windows.

Ändrad i version 3.2: Ändrat till en namngiven tupel och lagt till service_pack_minor, service_pack_major, suite_mask och product_type.

Ändrad i version 3.6: Lagt till plattform_version

sys.get_asyncgen_hooks()¶: Returnerar ett asyncgen_hooks-objekt, som liknar en namedtuple av formen (firstiter, finalizer), där firstiter och finalizer förväntas vara antingen None eller funktioner som tar en asynchronous generator iterator som argument, och används för att schemalägga slutförande av en asynkron generator med en händelseslinga.

Tillagd i version 3.6: Se PEP 525 för mer information.

Anteckning

Denna funktion har lagts till på provisorisk basis (se PEP 411 för detaljer)

sys.get_coroutine_origin_tracking_depth()¶: Hämta det aktuella spårningsdjupet för coroutine-ursprunget, enligt inställningen i set_coroutine_origin_tracking_depth().

Tillagd i version 3.7.

Anteckning

Denna funktion har lagts till tillfälligt (se PEP 411 för detaljer.) Använd den endast i felsökningssyfte.

sys.hash_info¶

En named tuple som anger parametrar för implementeringen av numerisk hash. För mer information om hashing av numeriska typer, se Hashning av numeriska typer.

hash_info.width¶: Bredden i bitar som används för hash-värden

hash_info.modulus¶: Primtalsmodulen P som används för numeriskt hashschema

hash_info.inf¶: Det hashvärde som returneras för en positiv oändlighet

hash_info.nan¶: (Detta attribut används inte längre)

hash_info.imag¶: Den multiplikator som används för imaginärdelen av ett komplext tal

hash_info.algorithm¶: Namnet på algoritmen för hashing av str, bytes och memoryview

hash_info.hash_bits¶: Hashalgoritmens interna utmatningsstorlek

hash_info.seed_bits¶: Storleken på seed-nyckeln för hashalgoritmen

Tillagd i version 3.2.

Ändrad i version 3.4: Lagt till algoritm, hash_bits och seed_bits

sys.hexversion¶

Versionsnumret kodat som ett heltal. Detta ökar garanterat med varje version, inklusive korrekt stöd för icke-produktionsversioner. Om du t.ex. vill testa att Python-tolken är minst version 1.5.2 använder du:

if sys.hexversion >= 0x010502F0:
    # använd någon avancerad funktion
    ...
else:
    # använd en alternativ implementering eller varna användaren
    ...

Detta kallas hexversion eftersom det egentligen bara ser meningsfullt ut när det ses som resultatet av att skicka det till den inbyggda funktionen hex(). named tuple sys.version_info kan användas för en mer människovänlig kodning av samma information.

Mer information om hexversion finns på Versionering av API och ABI.

sys.implementation¶

Ett objekt som innehåller information om implementeringen av den Python-tolk som körs för närvarande. Följande attribut måste finnas i alla Python-implementationer.

name är implementeringens identifierare, t.ex. 'cpython'. Den faktiska strängen definieras av Python-implementationen, men det är garanterat att den är gemener.

version är en namngiven tupel, i samma format som sys.version_info. Den representerar versionen av Python implementationen. Detta har en annan betydelse än den specifika versionen av Python språk som den aktuella tolken följer, som sys.version_info representerar. Till exempel, för PyPy 1.8 kan sys.implementation.version vara sys.version_info(1, 8, 0, 'final', 0), medan sys.version_info skulle vara sys.version_info(2, 7, 2, 'final', 0). För CPython är de samma värde, eftersom det är referensimplementationen.

hexversion är implementationsversionen i hexadecimalt format, som sys.hexversion.

cache_tag är den tagg som används av importmaskineriet i filnamnen för cachade moduler. Enligt konvention skulle det vara en sammansättning av implementeringens namn och version, som 'cpython-33'. En Python-implementation kan dock använda något annat värde om det är lämpligt. Om cache_tag är satt till None, indikerar det att modulcachning bör inaktiveras.

supports_isolated_interpreters är ett booleanskt värde som anger om implementationen stöder flera isolerade tolkar. Det är True för CPython på de flesta plattformar. Plattformar med detta stöd implementerar lågnivåmodulen _interpreters.

Se även

PEP 684, PEP 734, och concurrent.interpreters.

sys.implementation kan innehålla ytterligare attribut som är specifika för Python-implementationen. Dessa icke-standardiserade attribut måste börja med ett understreck och beskrivs inte här. Oavsett innehåll kommer sys.implementation inte att ändras under en körning av tolken, eller mellan olika implementationsversioner. (Det kan dock ändras mellan Python-språkversioner.) Se PEP 421 för mer information.

Tillagd i version 3.3.

Ändrad i version 3.14: Fältet upports_isolated_interpreters har lagts till.

Anteckning

Tillägg av nya obligatoriska attribut måste gå igenom den normala PEP-processen. Se PEP 421 för mer information.

sys.int_info¶

En named tuple som innehåller information om Pythons interna representation av heltal. Attributen är skrivskyddade.

int_info.bits_per_digit¶: Antalet bitar som finns i varje siffra. Pythons heltal lagras internt i basen 2**int_info.bits_per_digit.

int_info.sizeof_digit¶: Storleken i bytes på den C-typ som används för att representera en siffra.

int_info.default_max_str_digits¶: Standardvärdet för sys.get_int_max_str_digits() när det inte uttryckligen har konfigurerats på annat sätt.

int_info.str_digits_check_threshold¶: Det minsta värdet som inte är noll för sys.set_int_max_str_digits(), PYTHONINTMAXSTRDIGITS, eller -X int_max_str_digits.

Tillagd i version 3.1.

Ändrad i version 3.11: Lagt till default_max_str_digits och str_digits_check_threshold.

sys.__interactivehook__¶

När detta attribut finns, anropas dess värde automatiskt (utan argument) när tolken startas i interaktivt läge. Detta görs efter att filen PYTHONSTARTUP har lästs, så att du kan ställa in den här hooken där. Modulen site ställer in detta.

Utlöser en auditing event cpython.run_interactivehook med hook-objektet som argument när hooken anropas vid start.

Tillagd i version 3.4.

sys.intern(string)¶

Ange sträng i tabellen över ”internerade” strängar och returnera den internerade strängen - som är sträng själv eller en kopia. Att internera strängar är användbart för att vinna lite prestanda vid uppslagning i ordböcker – om nycklarna i en ordbok är internerade och uppslagningsnyckeln är internerad kan nyckeljämförelserna (efter hashning) göras med en pekarjämförelse i stället för en strängjämförelse. Normalt är de namn som används i Python-program automatiskt internerade, och de ordböcker som används för att hålla modul-, klass- eller instansattribut har internerade nycklar.

Internerade strängar är inte immortal; du måste behålla en referens till returvärdet för intern() för att kunna dra nytta av det.

sys._is_gil_enabled()¶: Returnerar True om GIL är aktiverad och False om den är inaktiverad.

Tillagd i version 3.13.

Det är inte garanterat att den finns i alla implementationer av Python.

sys.is_finalizing()¶

Returnerar True om Pythons huvudtolk shutting down. Returnerar False annars.

Se även undantaget PythonFinalizationError.

Tillagd i version 3.5.

sys._jit¶

Verktyg för att observera just-in-time-kompilering.

JIT-kompilering är en experimentell implementeringsdetalj i CPython. det är inte garanterat att sys._jit existerar eller beter sig på samma sätt i alla Python-implementationer, versioner eller byggkonfigurationer.

Tillagd i version 3.14.

_jit.is_available()¶: Returnerar True om den aktuella Python-körbara filen stöder JIT-kompilering, och False annars. Detta kan kontrolleras genom att bygga CPython med alternativet \--experimental-jit på Windows, och alternativet --enable-experimental-jit på alla andra plattformar.

_jit.is_enabled()¶: Returnerar True om JIT-kompilering är aktiverad för den aktuella Python-processen (implicerar sys._jit.is_available()), och False annars. Om JIT-kompilering är tillgänglig kan detta kontrolleras genom att ställa in miljövariabeln PYTHON_JIT till 0 (inaktiverad) eller 1 (aktiverad) vid start av tolken.

_jit.is_active()¶

Returnerar True om den översta Python-rutan för närvarande kör JIT-kod (implicerar sys._jit.is_enabled()), och False annars.

Anteckning

Denna funktion är avsedd för testning och felsökning av själva JIT. Den bör undvikas för alla andra ändamål.

Anteckning

På grund av att JIT-kompilatorer spåras kan upprepade anrop till denna funktion ge överraskande resultat. Till exempel kommer förgrening på dess returvärde sannolikt att leda till oväntat beteende (om det gör att JIT-kod skrivs in eller avslutas):

>>> for warmup in range(BIG_NUMBER):
...     # This line is "hot", and is eventually JIT-compiled:
...     if sys._jit.is_active():
...         # This line is "cold", and is run in the interpreter:
...         assert sys._jit.is_active()
...
Traceback (most recent call last):
  File "<stdin>", line 5, in <module>
    assert sys._jit.is_active()
           ~~~~~~~~~~~~~~~~~~^^
AssertionError

sys.last_exc¶: Denna variabel är inte alltid definierad; den sätts till undantagsinstansen när ett undantag inte hanteras och tolken skriver ut ett felmeddelande och en stackspårning. Den är avsedd att användas så att en interaktiv användare kan importera en felsökningsmodul och utföra felsökning efteråt utan att behöva utföra kommandot som orsakade felet igen. (Typisk användning är import pdb; pdb.pm() för att komma in i post-mortem-felsökaren; se pdb-modulen för mer information)

Tillagd i version 3.12.

sys._is_immortal(op)¶: Returnerar True om det givna objektet är immortal, False annars.

Anteckning

Objekt som är odödliga (och därmed returnerar True när de skickas till denna funktion) garanteras inte vara odödliga i framtida versioner, och vice versa för dödliga objekt.

Tillagd i version 3.14.

Denna funktion bör endast användas för specialiserade ändamål. Det är inte garanterat att den finns i alla implementationer av Python.

sys._is_interned(string)¶: Returnerar True om den givna strängen är ”interned”, False annars.

Tillagd i version 3.13.

Det är inte garanterat att den finns i alla implementationer av Python.

sys.last_type¶
sys.last_value¶
sys.last_traceback¶: Dessa tre variabler är föråldrade; använd sys.last_exc istället. De innehåller den äldre representationen av sys.last_exc, som returneras från exc_info() ovan.

sys.maxsize¶: Ett heltal som anger det maximala värde som en variabel av typen Py_ssize_t kan anta. Det är vanligtvis 2**31 - 1 på en 32-bitars plattform och 2**63 - 1 på en 64-bitars plattform.

sys.maxunicode¶: Ett heltal som anger värdet för den största Unicode-kodpunkten, dvs. 1114111 (0x10FFFF i hexadecimal).

Ändrad i version 3.3: Före PEP 393 brukade sys.maxunicode vara antingen 0xFFFF eller 0x10FFFF, beroende på det konfigurationsalternativ som angav om Unicode-tecken lagrades som UCS-2 eller UCS-4.

sys.meta_path¶

En lista över meta path finder-objekt som har sina find_spec()-metoder anropade för att se om ett av objekten kan hitta den modul som ska importeras. Som standard innehåller den poster som implementerar Pythons standardimport-semantik. Metoden find_spec() anropas med åtminstone det absoluta namnet på den modul som importeras. Om modulen som ska importeras ingår i ett paket, skickas det överordnade paketets attribut __path__ in som ett andra argument. Metoden returnerar en module spec, eller None om modulen inte kan hittas.

Se även

importlib.abc.MetaPathFinder: Den abstrakta basklassen som definierar gränssnittet för sökobjekt på meta_path.
importlib.machinery.ModuleSpec: Den konkreta klass som find_spec() ska returnera instanser av.

Ändrad i version 3.4: Modulspecifikationer introducerades i Python 3.4, av PEP 451.

Ändrad i version 3.12: Tog bort fallbacken som letade efter en find_module()-metod om en meta_path-post inte hade en find_spec()-metod.

sys.modules¶: Detta är en ordbok som mappar modulnamn till moduler som redan har laddats. Detta kan manipuleras för att tvinga fram omladdning av moduler och andra trick. Att byta ut ordlistan kommer dock inte nödvändigtvis att fungera som förväntat och att ta bort viktiga objekt från ordlistan kan leda till att Python misslyckas. Om du vill iterera över denna globala ordbok ska du alltid använda sys.modules.copy() eller tuple(sys.modules) för att undvika undantag eftersom dess storlek kan ändras under iterationen som en bieffekt av kod eller aktivitet i andra trådar.

sys.orig_argv¶

Listan över de ursprungliga kommandoradsargumenten som skickades till Pythons körbara program.

Elementen i sys.orig_argv är argumenten till Python-tolken, medan elementen i sys.argv är argumenten till användarens program. Argument som används av själva tolken kommer att finnas i sys.orig_argv och saknas i sys.argv.

Tillagd i version 3.10.

sys.path¶

En lista med strängar som anger sökvägen för moduler. Initialiseras från miljövariabeln PYTHONPATH, plus en installationsberoende standard.

Som standard, när programmet initieras vid programstart, läggs en potentiellt osäker sökväg till i sys.path (före de poster som infogas som ett resultat av PYTHONPATH):

python -m module kommandorad: lägg till den aktuella arbetskatalogen före.
python script.py kommandorad: lägg till skriptets katalog före. Om det är en symbolisk länk, lös symboliska länkar.
kommandoraderna python -c code och python (REPL): föregås av en tom sträng, vilket betyder den aktuella arbetskatalogen.

Om du inte vill lägga till denna potentiellt osäkra sökväg använder du kommandoradsalternativet -P eller miljövariabeln PYTHONSAFEPATH.

Det står ett program fritt att modifiera denna lista för sina egna syften. Endast strängar bör läggas till i sys.path; alla andra datatyper ignoreras under importen.

Se även

Modul site Detta beskriver hur man använder .pth-filer för att utöka sys.path.

sys.path_hooks¶

En lista med anropbara filer som tar ett sökvägsargument för att försöka skapa en finder för sökvägen. Om en sökare kan skapas, skall den returneras av anropbarheten, annars uppstår ImportError.

Ursprungligen specificerat i PEP 302.

sys.path_importer_cache¶

En ordbok som fungerar som en cache för finder-objekt. Nycklarna är sökvägar som har skickats till sys.path_hooks och värdena är de sökare som hittas. Om en sökväg är en giltig filsystemssökväg men ingen sökare hittas i sys.path_hooks så lagras None.

Ursprungligen specificerat i PEP 302.

sys.platform¶

En sträng som innehåller en plattformsidentifierare. Kända värden är:

System	`plattform` värde
AIX	`'aix'`
Android	`'android'`
Emscripten	`'emscripten'`
FreeBSD	`'freebsd'`
iOS	`'ios'`
Linux	`'linux'`
macOS	”Darwin
Fönster	`'win32'`
Windows/Cygwin	`'cygwin'`
WASI	`'wasi'`

På Unix-system som inte listas i tabellen är värdet det gemena OS-namnet som returneras av uname -s, med den första delen av versionen som returneras av uname -r tillagd, t.ex. 'sunos5', vid den tidpunkt då Python byggdes. Om du inte vill testa för en specifik systemversion rekommenderas det därför att du använder följande idiom:

if sys.platform.startswith('sunos'):
    # SunOS-specifik kod här...

Ändrad i version 3.3: På Linux innehåller sys.platform inte längre huvudversionen. Den är alltid 'linux, i stället för 'linux2 eller 'linux3.

Ändrad i version 3.8: På AIX innehåller sys.platform inte längre huvudversionen. Den är alltid 'aix', i stället för 'aix5' eller 'aix7'.

Ändrad i version 3.13: På Android returnerar sys.platform nu 'android' i stället för 'linux'.

Ändrad i version 3.14: På FreeBSD innehåller sys.platform inte huvudversionen längre. Den är alltid 'freebsd', istället för 'freebsd13' eller 'freebsd14'.

Se även

os.name har en grövre granularitet. os.uname() ger systemberoende versionsinformation.

Modulen platform ger detaljerade kontroller av systemets identitet.

sys.platlibdir¶

Namnet på den plattformsspecifika bibliotekskatalogen. Den används för att bygga upp sökvägen till standardbiblioteket och sökvägarna till installerade tilläggsmoduler.

Det är lika med "lib" på de flesta plattformar. På Fedora och SuSE är det lika med "lib64" på 64-bitars plattformar vilket ger följande sys.path sökvägar (där X.Y är Python major.minor version):

/usr/lib64/pythonX.Y/: Standardbibliotek (som os.py i modulen os)
/usr/lib64/pythonX.Y/lib-dynload/: C-tilläggsmoduler till standardbiblioteket (som errno-modulen, det exakta filnamnet är plattformsspecifikt)
/usr/lib/pythonX.Y/site-packages/ (använd alltid lib, inte sys.platlibdir): Moduler från tredje part
/usr/lib64/pythonX.Y/site-packages/: C-tilläggsmoduler för tredjepartspaket

Tillagd i version 3.9.

sys.prefix¶: En sträng som anger det platsspecifika katalogprefix där de plattformsoberoende Python-filerna installeras; på Unix är standardvärdet /usr/local. Detta kan ställas in vid byggtiden med --prefix-argumentet i configure-skriptet. Se Installationsvägar för härledda sökvägar.

Anteckning

Om en virtuell miljö är i kraft, kommer detta prefix att peka på den virtuella miljön. Värdet för Python-installationen kommer fortfarande att vara tillgängligt via base_prefix. Se Virtuella miljöer för mer information.

Ändrad i version 3.14: Vid körning under en virtuell miljö, sätts nu prefix och exec_prefix till prefixet för den virtuella miljön av path initialization, istället för site. Detta innebär att prefix och exec_prefix alltid pekar på den virtuella miljön, även när site är inaktiverat (-S).

sys.ps1¶
sys.ps2¶: Strings specifying the primary and secondary prompt of the interpreter. These are only defined if the interpreter is in interactive mode. Their initial values in this case are '>>> ' and '... '. If a non-string object is assigned to either variable, its str() is re-evaluated each time the interpreter prepares to read a new interactive command; this can be used to implement a dynamic prompt.

sys.setdlopenflags(n)¶: Ställ in de flaggor som används av tolken för dlopen()-anrop, t.ex. när tolken laddar tilläggsmoduler. Detta kommer bland annat att möjliggöra en lat upplösning av symboler vid import av en modul, om det kallas som sys.setdlopenflags(0). För att dela symboler mellan tilläggsmoduler, anropa som sys.setdlopenflags(os.RTLD_GLOBAL). Symboliska namn för flaggvärdena finns i os-modulen (RTLD_xxx-konstanter, t.ex. os.RTLD_LAZY).

Tillgänglighet: Unix.

sys.set_int_max_str_digits(maxdigits)¶: Ställer in begränsning av längd för omvandling av heltalssträngar som används av denna tolk. Se även get_int_max_str_digits().

Tillagd i version 3.11.

sys.setprofile(profilefunc)¶

Ställ in systemets profilfunktion, som gör att du kan implementera en Python-källkodsprofilerare i Python. Se kapitel Python-profiler för mer information om Python-profileraren. Systemets profilfunktion anropas på samma sätt som systemets trace-funktion (se settrace()), men den anropas med olika händelser, t.ex. anropas den inte för varje exekverad kodrad (endast vid anrop och retur, men returhändelsen rapporteras även när ett undantag har ställts in). Funktionen är trådspecifik, men det finns inget sätt för profileraren att veta om kontextbyten mellan trådar, så det är inte meningsfullt att använda den när det finns flera trådar. Dess returvärde används inte heller, så det kan helt enkelt returnera None. Fel i profilfunktionen kommer att leda till att den själv nollställs.

Anteckning

Samma spårningsmekanism används för setprofile() som för settrace(). För att spåra anrop med setprofile() inuti en spårningsfunktion (t.ex. i en brytpunkt i en debugger), se call_tracing().

Profilfunktioner ska ha tre argument: frame, event och arg. frame är den aktuella stackramen. event är en sträng: 'call', 'return', 'c_call', 'c_return' eller 'c_exception'. arg beror på händelsetypen.

Händelserna har följande innebörd:

”Ring: En funktion anropas (eller något annat kodblock skrivs in). Profilfunktionen anropas; arg är None.
'return': En funktion (eller annat kodblock) är på väg att returneras. Profilfunktionen anropas; arg är det värde som kommer att returneras, eller None om händelsen orsakas av att ett undantag tas upp.
'c_call': En C-funktion är på väg att anropas. Detta kan vara en tilläggsfunktion eller en inbyggd funktion. arg är C-funktionens objekt.
'c_return': En C-funktion har returnerats. arg är C-funktionens objekt.
'c_exception': En C-funktion har löst ut ett undantag. arg är C-funktionens objekt.

Utlöser en auditing event sys.setprofile utan argument.

sys.setrecursionlimit(limit)¶

Ställ in det maximala djupet på Python-tolkens stack till limit. Denna gräns förhindrar oändlig rekursion från att orsaka ett överflöd av C-stacken och krascha Python.

Den högsta möjliga gränsen är plattformsberoende. En användare kan behöva sätta gränsen högre om han eller hon har ett program som kräver djup rekursion och en plattform som stöder en högre gräns. Detta bör göras med försiktighet, eftersom en för hög gräns kan leda till en krasch.

Om den nya gränsen är för låg vid det aktuella rekursionsdjupet, utlöses ett RecursionError undantag.

Ändrad i version 3.5.1: Ett RecursionError-undantag görs nu om den nya gränsen är för låg med det aktuella rekursionsdjupet.

sys.setswitchinterval(interval)¶: Ställ in tolkens trådbytesintervall (i sekunder). Detta värde med flyttal bestämmer den ideala varaktigheten för de ”timeslices” som allokeras till Python-trådar som körs samtidigt. Observera att det faktiska värdet kan vara högre, särskilt om interna funktioner eller metoder med lång löptid används. Vilken tråd som blir schemalagd i slutet av intervallet är också operativsystemets beslut. Tolken har inte någon egen schemaläggare.

Tillagd i version 3.2.

sys.settrace(tracefunc)¶

Ställ in systemets spårningsfunktion, som gör att du kan implementera en Python-felsökare för källkod i Python. Funktionen är trådspecifik; för att en felsökare ska stödja flera trådar måste den registrera en spårningsfunktion med settrace() för varje tråd som felsöks eller använda threading.settrace().

Spårningsfunktioner bör ha tre argument: frame, event och arg. frame är den aktuella stackramen. event är en sträng: 'call', 'line', 'return', 'exception' eller 'opcode'. arg beror på händelsetypen.

Trace-funktionen anropas (med event satt till 'call') när ett nytt lokalt scope skrivs in; den ska returnera en referens till en lokal trace-funktion som ska användas för det nya scopet, eller None om scopet inte ska spåras.

Den lokala spårningsfunktionen bör returnera en referens till sig själv eller till en annan funktion som sedan används som lokal spårningsfunktion för området.

Om det uppstår något fel i trace-funktionen kommer den att avaktiveras, precis som när settrace(None) anropas.

Anteckning

Spårning inaktiveras när spårningsfunktionen anropas (t.ex. en funktion som anges av settrace()). För rekursiv spårning se call_tracing().

Händelserna har följande innebörd:

”Ring: En funktion anropas (eller något annat kodblock skrivs in). Den globala spårningsfunktionen anropas; arg är None; returvärdet anger den lokala spårningsfunktionen.
'line': Tolken är på väg att exekvera en ny kodrad eller åter exekvera villkoret i en slinga. Den lokala trace-funktionen anropas; arg är None; returvärdet specificerar den nya lokala trace-funktionen. Se Objects/lnotab_notes.txt för en detaljerad förklaring av hur detta fungerar. Händelser per rad kan inaktiveras för en ram genom att sätta f_trace_lines till False på den ramen.
'return': En funktion (eller annat kodblock) är på väg att returneras. Den lokala trace-funktionen anropas; arg är det värde som ska returneras, eller None om händelsen orsakas av att ett undantag tas upp. Trace-funktionens returvärde ignoreras.
'exception': Ett undantag har inträffat. Den lokala spårningsfunktionen anropas; arg är en tupel (exception, value, traceback); returvärdet anger den nya lokala spårningsfunktionen.
'opcode': Tolken är på väg att exekvera en ny opkod (se dis för detaljer om opkoder). Den lokala spårningsfunktionen anropas; arg är None; returvärdet specificerar den nya lokala spårningsfunktionen. Per-opcode-händelser sänds inte ut som standard: de måste uttryckligen begäras genom att sätta f_trace_opcodes till True på frame.

Observera att när ett undantag sprids nedåt i kedjan av anropare, genereras en 'exception' på varje nivå.

För mer finkornig användning är det möjligt att ställa in en spårningsfunktion genom att tilldela frame.f_trace = tracefunc explicit, snarare än att förlita sig på att den ställs in indirekt via returvärdet från en redan installerad spårningsfunktion. Detta krävs också för att aktivera spårningsfunktionen på den aktuella ramen, vilket settrace() inte gör. Observera att för att detta ska fungera måste en global spårningsfunktion ha installerats med settrace() för att aktivera spårningsmaskineriet under körning, men det behöver inte vara samma spårningsfunktion (det kan t.ex. vara en spårningsfunktion med låg overhead som helt enkelt returnerar None för att inaktivera sig själv omedelbart vid varje bildruta).

För mer information om kod- och ramobjekt, se Standardtypens hierarki.

Utlöser en auditing event sys.settrace utan argument.

Funktionen settrace() är endast avsedd för implementering av debuggar, profilerare, täckningsverktyg och liknande. Dess beteende är en del av implementeringsplattformen, snarare än en del av språkdefinitionen, och är därför kanske inte tillgänglig i alla Python-implementeringar.

Ändrad i version 3.7: händelsetypen 'opcode' tillagd; attributen f_trace_lines och f_trace_opcodes tillagda för ramar

sys.set_asyncgen_hooks([firstiter] [, finalizer])¶

Accepterar två valfria nyckelordsargument som är anropbara som accepterar en asynkron generator iterator som argument. Anropet firstiter kommer att anropas när en asynkron generator itereras för första gången. Anropsobjektet finalizer anropas när en asynkron generator är på väg att sopuppsamlas.

Utlöser en auditing event sys.set_asyncgen_hooks_firstiter utan argument.

Utlöser en auditing event sys.set_asyncgen_hooks_finalizer utan argument.

Två revisionshändelser utlöses eftersom det underliggande API:et består av två anrop som var och en måste utlösa sin egen händelse.

Tillagd i version 3.6: Se PEP 525 för mer information, och för ett referensexempel på en finalizer-metod se implementeringen av asyncio.Loop.shutdown_asyncgens i Lib/asyncio/base_events.py`

Anteckning

Denna funktion har lagts till på provisorisk basis (se PEP 411 för detaljer)

sys.set_coroutine_origin_tracking_depth(depth)¶

Gör det möjligt att aktivera eller inaktivera spårning av coroutine-ursprung. När det är aktiverat kommer attributet cr_origin på coroutine-objekt att innehålla en tupel av (filnamn, radnummer, funktionsnamn) tuplar som beskriver spårningen där coroutine-objektet skapades, med det senaste anropet först. När cr_origin är inaktiverat kommer det att vara None.

För att aktivera, skicka ett djup-värde större än noll; detta anger antalet bildrutor vars information kommer att fångas upp. För att inaktivera, sätt depth till noll.

Denna inställning är trådspecifik.

Tillagd i version 3.7.

Anteckning

Denna funktion har lagts till tillfälligt (se PEP 411 för detaljer.) Använd den endast i felsökningssyfte.

sys.activate_stack_trampoline(backend, /)¶

Aktivera trampolinen för stackprofilering backend. Den enda backend som stöds är "perf".

Stapeltrampoliner kan inte aktiveras om JIT är aktiv.

Tillgänglighet: Linux.

Tillagd i version 3.12.

Se även

sys.deactivate_stack_trampoline()¶

Avaktivera den aktuella backend-trampolinen för stackprofilering.

Om ingen stackprofilering är aktiverad har denna funktion ingen effekt.

Tillgänglighet: Linux.

Tillagd i version 3.12.

sys.is_stack_trampoline_active()¶: Returnerar True om en trampolin för stackprofilering är aktiv.

Tillgänglighet: Linux.

Tillagd i version 3.12.

sys.remote_exec(pid, script)¶

Exekverar script, en fil som innehåller Python-kod i fjärrprocessen med den angivna pid.

Denna funktion returnerar omedelbart och koden kommer att exekveras av målprocessens huvudtråd vid nästa tillfälle, på samma sätt som signaler hanteras. Det finns inget gränssnitt för att avgöra när koden har exekverats. Anroparen ansvarar för att filen fortfarande finns kvar när fjärrprocessen försöker läsa den och att den inte har skrivits över.

Fjärrprocessen måste köra en CPython-tolk med samma större och mindre version som den lokala processen. Om antingen den lokala eller fjärrtolken är en pre-release (alpha, beta eller releasekandidat) måste den lokala och fjärrtolken ha exakt samma version.

När koden körs i fjärrprocessen utlöses en auditing event sys.remote_exec med pid och sökvägen till skriptfilen. Den här händelsen utlöses i den process som anropade sys.remote_exec().

När skriptet körs i fjärrprocessen skapas en auditing event cpython.remote_debugger_script med sökvägen i fjärrprocessen. Denna händelse utlöses i fjärrprocessen, inte i den som anropade sys.remote_exec().

Tillgänglighet: Unix, Windows.

Tillagd i version 3.14.

sys._enablelegacywindowsfsencoding()¶

Ändrar filesystem encoding and error handler till ’mbcs’ respektive ’replace’, för överensstämmelse med versioner av Python före 3.6.

Detta motsvarar att definiera miljövariabeln PYTHONLEGACYWINDOWSFSENCODING innan Python startas.

Se även sys.getfilesystemencoding() och sys.getfilesystemencodeerrors().

Tillgänglighet: Windows.

Anteckning

Att ändra filsystemets kodning efter Python-start är riskabelt eftersom den gamla fsenkodningen eller sökvägar kodade med den gamla fsenkodningen kan vara cachade någonstans. Använd PYTHONLEGACYWINDOWSFSENCODING istället.

Tillagd i version 3.6: Se PEP 529 för mer information.

Deprecated since version 3.13, will be removed in version 3.16: Använd PYTHONLEGACYWINDOWSFSENCODING istället.

sys.stdin¶

sys.stdout¶

sys.stderr¶

Filobjekt används av tolken för standardinmatning, -utmatning och -fel:

stdin används för all interaktiv inmatning (inklusive anrop till input());
stdout används för utdata från print() och expression och för uppmaningar från input();
Tolkens egna uppmaningar och dess felmeddelanden går till stderr.

Dessa strömmar är vanliga textfiler som de som returneras av funktionen open(). Deras parametrar väljs enligt följande:

Kodning och felhantering initialiseras från PyConfig.stdio_encoding och PyConfig.stdio_errors.

I Windows används UTF-8 för konsolenheten. Enheter som inte innehåller tecken, t.ex. diskfiler och pipes, använder systemets lokala kodning (d.v.s. ANSI-kodningen). Enheter som inte innehåller konsoltecken, t.ex. NUL (dvs. där isatty() returnerar True), använder värdet på konsolens kodsidor för in- och utmatning vid start, för stdin respektive stdout/stderr. Detta är standardvärdet för systemets locale encoding om processen inte initialt är kopplad till en konsol.

Konsolens speciella beteende kan åsidosättas genom att ställa in miljövariabeln PYTHONLEGACYWINDOWSSTDIO innan Python startas. I så fall används konsolens kodsidor på samma sätt som för alla andra teckenenheter.

Under alla plattformar kan du åsidosätta teckenkodningen genom att ställa in miljövariabeln PYTHONIOENCODING innan du startar Python eller genom att använda det nya kommandoradsalternativet -X utf8 och miljövariabeln PYTHONUTF8. För Windows-konsolen gäller detta dock endast när PYTHONLEGACYWINDOWSSTDIO också är inställd.
När den är interaktiv är strömmen stdout radbuffrad. Annars är den blockbuffrad som vanliga textfiler. Strömmen stderr är radbuffrad i båda fallen. Du kan göra båda strömmarna obuffrade genom att ange kommandoradsalternativet -u eller ställa in miljövariabeln PYTHONUNBUFFERED.

Ändrad i version 3.9: Icke-interaktiva stderr är nu linje-buffrad istället för fullt buffrad.

Anteckning

För att skriva eller läsa binära data från/till standardströmmarna, använd det underliggande binära buffer-objektet. Om du t.ex. vill skriva byte till stdout använder du sys.stdout.buffer.write(b'abc').

Men om du skriver ett bibliotek (och inte kontrollerar i vilket sammanhang dess kod kommer att exekveras), var medveten om att standardströmmarna kan ersättas med filliknande objekt som io.StringIO som inte stöder attributet buffer.

sys.__stdin__¶

sys.__stdout__¶

sys.__stderr__¶

Dessa objekt innehåller de ursprungliga värdena för stdin, stderr och stdout i början av programmet. De används under slutförandet och kan vara användbara för att skriva ut till den faktiska standardströmmen oavsett om objektet sys.std* har omdirigerats.

Den kan också användas för att återställa de faktiska filerna till kända fungerande filobjekt om de har skrivits över med ett trasigt objekt. Det bästa sättet att göra detta är dock att uttryckligen spara den tidigare strömmen innan den ersätts, och återställa det sparade objektet.

Anteckning

Under vissa förhållanden kan stdin, stdout och stderr samt originalvärdena __stdin__, __stdout__ och __stderr__ vara None. Det är vanligtvis fallet för Windows GUI-appar som inte är anslutna till en konsol och Python-appar som startas med pythonw.

sys.stdlib_module_names¶

En uppsättning strängar som innehåller namnen på standardbiblioteksmoduler.

Den är densamma på alla plattformar. Moduler som inte är tillgängliga på vissa plattformar och moduler som inaktiveras vid Python-byggandet listas också. Alla modultyper listas: ren Python, inbyggda, frysta och tilläggsmoduler. Testmoduler är exkluderade.

För paket listas endast huvudpaketet: underpaket och undermoduler listas inte. Till exempel listas paketet email, men underpaketet email.mime och undermodulen email.message listas inte.

Se även listan sys.builtin_module_names.

Tillagd i version 3.10.

sys.thread_info¶

En named tuple som innehåller information om trådimplementeringen.

thread_info.name¶

Namnet på trådimplementeringen:

"nt": Windows-trådar
"pthread": POSIX-trådar
"pthread-stubs": stubbar POSIX-trådar (på WebAssembly-plattformar utan stöd för trådning)
"solaris": Solaris-trådar

thread_info.lock¶

Namnet på implementeringen av låset:

"semaphore": ett lås använder en semafor
"mutex+cond": ett lås använder en mutex och en villkorvariabel
None om denna information är okänd

thread_info.version¶: Namn och version av trådbiblioteket. Det är en sträng, eller None om denna information är okänd.

Tillagd i version 3.3.

sys.tracebacklimit¶: När denna variabel är inställd på ett heltalsvärde bestämmer den det maximala antalet nivåer av spårningsinformation som skrivs ut när ett ohanterat undantag inträffar. Standardvärdet är 1000. Om variabeln är inställd på ”0” eller mindre undertrycks all spårningsinformation och endast undantagstyp och värde skrivs ut.

sys.unraisablehook(unraisable, /)¶

Hantera ett undantag som inte kan bedömas.

Anropas när ett undantag har inträffat men det inte finns något sätt för Python att hantera det. Till exempel när en destruktor gör ett undantag eller under garbage collection (gc.collect()).

Argumentet unraisable har följande attribut:

exc_type: Typ av undantag.
exc_value: Undantagsvärde, kan vara None.
exc_traceback: Exception traceback, kan vara None.
err_msg: Felmeddelande, kan vara None.
objekt: Objekt som orsakar undantaget, kan vara None.

Standard-hook formaterar err_msg och object som: f'{err_msg}: {object!r}'; använd felmeddelandet ”Exception ignored in” om err_msg är None.

sys.unraisablehook() kan åsidosättas för att styra hur undantag som inte kan bedömas hanteras.

Se även

excepthook() som hanterar undantag som inte fångats upp.

Varning

Om du lagrar exc_value med en anpassad hook kan det skapa en referenscykel. Den bör rensas explicit för att bryta referenscykeln när undantaget inte längre behövs.

Om du lagrar object med en anpassad hook kan den återuppstå om den är inställd på ett objekt som håller på att slutföras. Undvik att lagra object efter att den anpassade hooken har slutförts för att undvika att objekt återuppstår.

Utlöser en granskningshändelse sys.unraisablehook med argumenten hook, unraisable när ett undantag som inte kan hanteras inträffar. Objektet unraisable är detsamma som det som kommer att skickas till hooken. Om ingen hook har ställts in, kan hook vara None.

Tillagd i version 3.8.

sys.version¶: En sträng som innehåller versionsnumret för Python-tolken plus ytterligare information om byggnummer och kompilator som använts. Denna sträng visas när den interaktiva tolken startas. Extrahera inte versionsinformation från den, använd hellre version_info och de funktioner som tillhandahålls av modulen platform.

sys.api_version¶

C API-versionen, motsvarande C-makrot PYTHON_API_VERSION. Definierad för bakåtkompatibilitet.

För närvarande uppdateras inte denna konstant i nya Python-versioner och är inte användbar för versionshantering. Detta kan komma att ändras i framtiden.

sys.version_info¶: En tupel som innehåller de fem komponenterna i versionsnumret: major, minor, micro, releaselevel och serial. Alla värden utom releaselevel är heltal; versionsnivån är 'alpha', 'beta', 'candidate' eller 'final'. Värdet för version_info som motsvarar Python version 2.0 är (2, 0, 0, 'final', 0). Komponenterna kan också nås via namn, så sys.version_info[0] är likvärdigt med sys.version_info.major och så vidare.

Ändrad i version 3.1: Namngivna komponentattribut har lagts till.

sys.warnoptions¶: Detta är en implementeringsdetalj av ramverket för varningar; ändra inte detta värde. Se modulen warnings för mer information om ramverket för varningar.

sys.winver¶: Versionsnumret som används för att skapa registernycklar på Windows-plattformar. Detta lagras som strängresurs 1000 i Python DLL. Värdet är normalt major- och minor-versionerna av den Python-tolk som körs. Det tillhandahålls i modulen sys för informationsändamål; att ändra detta värde har ingen effekt på de registernycklar som används av Python.

Tillgänglighet: Windows.

sys.monitoring: Namnrymd som innehåller funktioner och konstanter för att registrera callbacks och styra övervakningshändelser. Se sys.monitoring för mer information.

sys._xoptions¶

En ordbok med de olika implementationsspecifika flaggor som skickas via kommandoradsalternativet -X. Alternativnamn mappas antingen till sina värden, om de anges explicit, eller till True. Ett exempel:

$ ./python -Xa=b -Xc
Python 3.2a3+ (py3k, Oct 16 2010, 20:14:50)
[GCC 4.4.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys._xoptions
{'a': 'b', 'c': True}

Detta är ett CPython-specifikt sätt att komma åt alternativ som skickas via -X. Andra implementationer kan exportera dem på andra sätt, eller inte alls.

Tillagd i version 3.2.

Citeringar

[C99]

ISO/IEC 9899:1999. ”Programmeringsspråk – C.” Ett offentligt utkast av denna standard finns tillgängligt på https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf.

`sys` — Systemspecifika parametrar och funktioner¶

Föregående ämne

Nästa ämne

Denna sidan

sys — Systemspecifika parametrar och funktioner¶

`sys` — Systemspecifika parametrar och funktioner¶