`inspect` — Inspektera live-objekt¶

Källkod: Lib/inspect.py

Modulen inspect innehåller flera användbara funktioner som hjälper dig att få information om aktiva objekt som moduler, klasser, metoder, funktioner, spårningar, ramobjekt och kodobjekt. Den kan till exempel hjälpa dig att undersöka innehållet i en klass, hämta källkoden för en metod, extrahera och formatera argumentlistan för en funktion eller få all information du behöver för att visa en detaljerad spårning.

Det finns fyra huvudtyper av tjänster som tillhandahålls av denna modul: typkontroll, hämtning av källkod, inspektion av klasser och funktioner samt undersökning av tolkens stack.

Typer och medlemmar¶

Funktionen getmembers() hämtar medlemmarna i ett objekt, t.ex. en klass eller en modul. De funktioner vars namn börjar med ”is” är huvudsakligen praktiska val för det andra argumentet till getmembers(). De hjälper dig också att avgöra när du kan förvänta dig att hitta följande specialattribut (se Importrelaterade attribut på modulobjekt för modulattribut):

Typ	Attribut	Beskrivning
class	__doc__	dokumentationssträng
	__name__	namn med vilket denna klass definierades
	__qualname__	kvalificerat namn
	__module__	namnet på den modul där denna klass definierades
	__type_params__	En tupel som innehåller typ-parametrar för en generisk klass
metod	__doc__	dokumentationssträng
	__name__	namn med vilket denna metod definierades
	__qualname__	kvalificerat namn
	__func__	funktionsobjekt som innehåller implementering av metod
	__self__	instans som denna metod är bunden till, eller `None`
	__module__	namn på modul där denna metod definierades
function	__doc__	dokumentationssträng
	__name__	namn med vilket denna funktion definierades
	__qualname__	kvalificerat namn
	__code__	kodobjekt som innehåller kompilerad funktion bytecode
	__defaults__	tupel av eventuella standardvärden för positions- eller nyckelordsparametrar
	__kwdefaults__	mappning av eventuella standardvärden för parametrar som endast innehåller nyckelord
	__globals__	global namnrymd där denna funktion definierades
	__builtins__	namnrymd för inbyggda komponenter
	__annotations__	mappning av parameternamn till annoteringar; `"return"` nyckel är reserverad för return-annoteringar.
	__type_params__	En tupel som innehåller typ-parametrarna för en generisk funktion
	__module__	namn på modul där denna funktion definierades
traceback	tb_frame	ramobjekt på denna nivå
	tb_lasti	index för det senaste försöket till instruktion i bytecode
	tb_lineno	aktuellt radnummer i Python-källkoden
	tb_next	nästa inre traceback-objekt (anropas av denna nivå)
frame	f_back	nästa yttre ramobjekt (den här ramens anropare)
	f_builtins	builtins namnrymd som ses av denna ram
	f_code	kodobjekt som exekveras i denna bildruta
	f_globals	global namnrymd som ses av denna ram
	f_lasti	index för det senaste försöket till instruktion i bytecode
	f_lineno	aktuellt radnummer i Python-källkoden
	f_locals	lokalt namnrymd som ses av denna ram
	f_generator	returnerar generatorn eller coroutine-objektet som äger den här ramen, eller `None` om ramen är en vanlig funktion
	f_trace	spårningsfunktion för denna ram, eller `None`
	f_trace_lines	ange om en spårningshändelse ska utlösas för varje källkodslinje
	f_trace_opcodes	ange om händelser per opcode begärs
	clear()	används för att rensa alla referenser till lokala variabler
code	co_argcount	antal argument (inkluderar inte argument med endast nyckelord, * eller ** args)
	co_code	sträng av rå kompilerad bytecode
	co_cellvars	tupel av namn på cellvariabler (refererade av innehållande scopes)
	co_consts	tuple av konstanter som används i bytekoden
	co_filename	namn på filen där detta kodobjekt skapades
	co_firstlineno	nummer på första raden i Python-källkod
	co_flags	bitmapp av `CO_*` flaggor, läs mer här
	co_lnotab	kodad mappning av radnummer till bytecode-index
	co_freevars	tupel av namn på fria variabler (refereras via en funktions closure)
	co_posonlyargcount	antal positionella argument
	co_kwonlyargcount	antal argument för endast nyckelord (ej inkluderande ** argument)
	co_name	namn med vilket detta kodobjekt definierades
	co_qualname	fullständigt kvalificerat namn med vilket detta kodobjekt definierades
	co_names	tupel av namn som inte är argument och funktionslokaler
	co_nlocals	antal lokala variabler
	co_stacksize	stackutrymme för virtuell maskin krävs
	co_varnames	tupel av namn på argument och lokala variabler
	co_lines()	returnerar en iterator som ger successiva bytecode-intervall
	co_positions()	returnerar en iterator med källkodspositioner för varje bytecode-instruktion
	replace()	returnerar en kopia av kodobjektet med nya värden
generator	__name__	namn
	__qualname__	kvalificerat namn
	gi_frame	frame
	gi_running	är generatorn igång?
	gi_code	code
	gi_yieldfrom	objekt som itereras av `yield from`, eller `None`
asynkron generator	__name__	namn
	__qualname__	kvalificerat namn
	ag_await	objektet som väntar på, eller `None`
	ag_frame	frame
	ag_running	är generatorn igång?
	ag_code	code
coroutine	__name__	namn
	__qualname__	kvalificerat namn
	cr_await	objektet som väntar på, eller `None`
	cr_frame	frame
	cr_running	är coroutinen igång?
	cr_code	code
	cr_origin	där coroutine skapades, eller `None`. Se `sys.set_coroutine_origin_tracking_depth()`
inbyggd	__doc__	dokumentationssträng
	__name__	ursprungliga namnet på denna funktion eller metod
	__qualname__	kvalificerat namn
	__self__	instans som en metod är bunden till, eller `None`

Ändrad i version 3.5: Lägg till attributen __qualname__ och gi_yieldfrom till generatorer.

Attributet __name__ för generatorer sätts nu utifrån funktionsnamnet, istället för kodnamnet, och det kan nu ändras.

Ändrad i version 3.7: Lägg till attributet cr_origin för coroutines.

Ändrad i version 3.10: Lägg till attributet __builtins__ för funktioner.

Ändrad i version 3.14: Lägg till attributet f_generator för ramar.

inspect.getmembers(object[, predicate])¶: Returnera alla medlemmar i ett objekt i en lista med par av (name, value) sorterade efter namn. Om det valfria argumentet predicate anges, som kommer att anropas med objektet value för varje medlem, inkluderas endast medlemmar för vilka predikatet returnerar ett sant värde.

Anteckning

getmembers() returnerar endast klassattribut som definieras i metaklassen när argumentet är en klass och dessa attribut har listats i metaklassens anpassade __dir__().

inspect.getmembers_static(object[, predicate])¶: Returnerar alla medlemmar i ett objekt i en lista med (namn, värde)-par sorterade efter namn utan att utlösa dynamisk sökning via deskriptorprotokollet, __getattr__ eller __getattribute__. Alternativt kan du bara returnera medlemmar som uppfyller ett givet predikat.

Anteckning

getmembers_static() kanske inte kan hämta alla medlemmar som getmembers kan hämta (som dynamiskt skapade attribut) och kan hitta medlemmar som getmembers inte kan (som deskriptorer som ger upphov till AttributeError). Den kan också returnera deskriptorobjekt i stället för instansmedlemmar i vissa fall.

Tillagd i version 3.11.

inspect.getmodulename(path)¶

Returnerar namnet på modulen som namnges av filen path, utan att inkludera namnen på omslutande paket. Filtillägget kontrolleras mot alla poster i importlib.machinery.all_suffixes(). Om det matchar returneras den slutliga sökvägskomponenten med tillägget borttaget. I annat fall returneras None.

Observera att denna funktion endast returnerar ett meningsfullt namn för faktiska Python-moduler - sökvägar som potentiellt hänvisar till Python-paket kommer fortfarande att returnera None.

Ändrad i version 3.3: Funktionen är direkt baserad på importlib.

inspect.ismodule(object)¶: Returnerar True om objektet är en modul.

inspect.isclass(object)¶: Returnerar True om objektet är en klass, oavsett om den är inbyggd eller skapad i Python-kod.

inspect.ismethod(object)¶: Returnerar True om objektet är en bunden metod skriven i Python.

inspect.ispackage(object)¶: Returnerar True om objektet är en package.

Tillagd i version 3.14.

inspect.isfunction(object)¶: Returnerar True om objektet är en Python-funktion, vilket inkluderar funktioner som skapats av ett lambda-uttryck.

inspect.isgeneratorfunction(object)¶: Returnerar True om objektet är en Python-generatorfunktion.

Ändrad i version 3.8: Funktioner inlindade i functools.partial() returnerar nu True om den inlindade funktionen är en Python-generatorfunktion.

Ändrad i version 3.13: Funktioner inlindade i functools.partialmethod() returnerar nu True om den inlindade funktionen är en Python-generatorfunktion.

inspect.isgenerator(object)¶: Returnerar True om objektet är en generator.

inspect.iscoroutinefunction(object)¶: Returnerar True om objektet är en coroutine function (en funktion definierad med en async def syntax), en functools.partial() som omsluter en coroutine function, eller en sync-funktion markerad med markcoroutinefunction().

Tillagd i version 3.5.

Ändrad i version 3.8: Funktioner inlindade i functools.partial() returnerar nu True om den inlindade funktionen är en coroutine function.

Ändrad i version 3.12: Synkroniseringsfunktioner markerade med markcoroutinefunction() returnerar nu True.

Ändrad i version 3.13: Funktioner inlindade i functools.partialmethod() returnerar nu True om den inlindade funktionen är en coroutine function.

inspect.markcoroutinefunction(func)¶

Dekorator för att markera en anropbar funktion som en coroutine function om den annars inte skulle upptäckas av iscoroutinefunction().

Detta kan vara användbart för sync-funktioner som returnerar en coroutine, om funktionen skickas till ett API som kräver iscoroutinefunction().

När det är möjligt är det att föredra att använda en async def-funktion. Det är också acceptabelt att anropa funktionen och testa returen med iscoroutine().

Tillagd i version 3.12.

inspect.iscoroutine(object)¶: Returnerar True om objektet är en coroutine som skapats av en async def-funktion.

Tillagd i version 3.5.

inspect.isawaitable(object)¶

Returnerar True om objektet kan användas i await-uttryck.

Kan också användas för att skilja generatorbaserade coroutines från vanliga generatorer:

import types

def gen():
    yield
@types.coroutine
def gen_coro():
    yield

assert not isawaitable(gen())
assert isawaitable(gen_coro())

Tillagd i version 3.5.

inspect.isasyncgenfunction(object)¶

Returnerar True om objektet är en asynkron generator-funktion, till exempel:

>>> async def agen():
...     yield 1
...
>>> inspect.isasyncgenfunction(agen)
True

Tillagd i version 3.6.

Ändrad i version 3.8: Funktioner inlindade i functools.partial() returnerar nu True om den inlindade funktionen är en asynkron generator-funktion.

Ändrad i version 3.13: Funktioner inlindade i functools.partialmethod() returnerar nu True om den inlindade funktionen är en coroutine function.

inspect.isasyncgen(object)¶: Returnerar True om objektet är en asynkron generator iterator skapad av en asynkron generator funktion.

Tillagd i version 3.6.

inspect.istraceback(object)¶: Returnerar True om objektet är en traceback.

inspect.isframe(object)¶: Returnerar True om objektet är en ram.

inspect.iscode(object)¶: Returnerar True om objektet är en kod.

inspect.isbuiltin(object)¶: Returnerar True om objektet är en inbyggd funktion eller en bunden inbyggd metod.

inspect.ismethodwrapper(object)¶

Returnerar True om objekttypen är en MethodWrapperType.

Dessa är instanser av MethodWrapperType, till exempel __str__(), __eq__() och __repr__().

Tillagd i version 3.11.

inspect.isroutine(object)¶: Returnerar True om objektet är en användardefinierad eller inbyggd funktion eller metod.

inspect.isabstract(object)¶: Returnerar True om objektet är en abstrakt basklass.

inspect.ismethoddescriptor(object)¶

Returnerar True om objektet är en metodbeskrivare, men inte om ismethod(), isclass(), isfunction() eller isbuiltin() är true.

Detta är till exempel sant för int.__add__. Ett objekt som klarar detta test har en __get__()-metod, men inte en __set__()-metod eller en __delete__()-metod. Utöver detta varierar uppsättningen attribut. Ett __name__-attribut är vanligtvis förnuftigt, och __doc__ är det ofta.

Metoder som implementeras via deskriptorer som också klarar något av de andra testerna returnerar False från ismethoddescriptor()-testet, helt enkelt för att de andra testerna lovar mer – du kan t.ex. räkna med att ha attributet __func__ (etc) när ett objekt klarar ismethod().

Ändrad i version 3.13: Denna funktion rapporterar inte längre felaktigt objekt med __get__() och __delete__(), men inte __set__(), som metoddeskriptorer (sådana objekt är databeskriptorer, inte metoddeskriptorer).

inspect.isdatadescriptor(object)¶

Returnerar True om objektet är en databeskrivare.

Databeskrivare har en __set__ eller en __delete__ metod. Exempel är properties (definierade i Python), getsets och members. De två sistnämnda definieras i C och det finns mer specifika tester tillgängliga för dessa typer, som är robusta över Python-implementationer. Vanligtvis har databeskrivare också attributen __name__ och __doc__ (properties, getsets och members har båda dessa attribut), men detta är inte garanterat.

inspect.isgetsetdescriptor(object)¶: Returnerar True om objektet är en getset-descriptor.

getsets är attribut som definieras i tilläggsmoduler via PyGetSetDef-strukturer. För Python-implementationer utan sådana typer kommer denna metod alltid att returnera False.

inspect.ismemberdescriptor(object)¶: Returnerar True om objektet är en member descriptor.

Medlemsdeskriptorer är attribut som definieras i tilläggsmoduler via PyMemberDef-strukturer. För Python-implementationer utan sådana typer kommer denna metod alltid att returnera False.

Hämtning av källkod¶

inspect.getdoc(object)¶: Hämtar dokumentationssträngen för ett objekt, rensad med cleandoc(). Om dokumentationssträngen för ett objekt inte anges och objektet är en klass, en metod, en egenskap eller en deskriptor, hämtas dokumentationssträngen från arvshierarkin. Returnerar None om dokumentationssträngen är ogiltig eller saknas.

Ändrad i version 3.5: Dokumentationssträngar ärvs nu om de inte åsidosätts.

inspect.getcomments(object)¶: Returnerar i en enda sträng alla rader med kommentarer som omedelbart föregår objektets källkod (för en klass, funktion eller metod), eller högst upp i Python-källfilen (om objektet är en modul). Om objektets källkod inte är tillgänglig returneras None. Detta kan hända om objektet har definierats i C eller i det interaktiva skalet.

inspect.getfile(object)¶: Returnerar namnet på den fil (text eller binär) i vilken ett objekt definierades. Detta kommer att misslyckas med ett TypeError om objektet är en inbyggd modul, klass eller funktion.

inspect.getmodule(object)¶: Försök att gissa vilken modul ett objekt definierades i. Returnerar None om modulen inte kan bestämmas.

inspect.getsourcefile(object)¶: Returnerar namnet på Python-källfilen där ett objekt definierades eller None om inget sätt kan identifieras för att hämta källan. Detta kommer att misslyckas med ett TypeError om objektet är en inbyggd modul, klass eller funktion.

inspect.getsourcelines(object)¶: Returnerar en lista med källrader och startradnummer för ett objekt. Argumentet kan vara en modul, klass, metod, funktion, traceback, frame eller kodobjekt. Källkoden returneras som en lista över de rader som motsvarar objektet och radnumret anger var i den ursprungliga källfilen den första kodraden hittades. Ett OSError genereras om källkoden inte kan hämtas. Ett TypeError visas om objektet är en inbyggd modul, klass eller funktion.

Ändrad i version 3.3: OSError tas upp i stället för IOError, som nu är ett alias för det förra.

inspect.getsource(object)¶: Returnerar texten i källkoden för ett objekt. Argumentet kan vara en modul, en klass, en metod, en funktion, en spårning, en ram eller ett kodobjekt. Källkoden returneras som en enda sträng. Ett OSError uppstår om källkoden inte kan hämtas. Ett TypeError visas om objektet är en inbyggd modul, klass eller funktion.

Ändrad i version 3.3: OSError tas upp i stället för IOError, som nu är ett alias för det förra.

inspect.cleandoc(doc)¶

Städa upp indrag från dokumentsträngar som är indragna för att stämma överens med kodblock.

Alla inledande blanksteg tas bort från den första raden. Alla inledande blanksteg som kan tas bort på ett enhetligt sätt från den andra raden och framåt tas bort. Tomma rader i början och slutet tas därefter bort. Dessutom expanderas alla tabbar till mellanslag.

Introspektering av anropsbara objekt med signaturobjektet¶

Tillagd i version 3.3.

Objektet Signature representerar anropssignaturen för ett anropsbart objekt och dess returannotation. För att hämta ett Signature-objekt, använd funktionen signature().

inspect.signature(callable, *, follow_wrapped=True, globals=None, locals=None, eval_str=False, annotation_format=Format.VALUE)¶

Returnerar ett Signature-objekt för den givna callable:

>>> from inspect import signature
>>> def foo(a, *, b:int, **kwargs):
...     pass

>>> sig = signature(foo)

>>> str(sig)
'(a, *, b: int, **kwargs)'

>>> str(sig.parameters['b'])
'b: int'

>>> sig.parameters['b'].annotation
<class 'int'>

Accepterar ett brett utbud av Python-anropsbara, från vanliga funktioner och klasser till functools.partial()-objekt.

Om några av anteckningarna är strängar (t.ex. för att from __future__ import annotations användes), kommer signature() att försöka att automatiskt avstränga anteckningarna med hjälp av annotationlib.get_annotations(). Parametrarna globals, locals och eval_str skickas till annotationlib.get_annotations() när anteckningarna löses upp; se dokumentationen för annotationlib.get_annotations() för instruktioner om hur dessa parametrar används. En medlem i enum annotationlib.Format kan skickas till parametern annotation_format för att styra formatet på de returnerade anteckningarna. Använd t.ex. annotation_format=annotationlib.Format.STRING för att returnera anteckningar i strängformat.

Utlöser ValueError om ingen signatur kan anges, och TypeError om den typen av objekt inte stöds. Om anteckningarna är strängade och eval_str inte är false, kan dessutom eval()-anropen för att avstränga anteckningarna i annotationlib.get_annotations() potentiellt ge upphov till alla typer av undantag.

Ett snedstreck (/) i signaturen för en funktion anger att parametrarna före den är endast positionella. För mer information, se FAQ-posten om parametrar som endast är positionella.

Ändrad i version 3.5: Parametern follow_wrapped har lagts till. Passera False för att få en signatur av callable specifikt (callable.__wrapped__ kommer inte att användas för att packa upp dekorerade callables)

Ändrad i version 3.10: Parametrarna globals, locals och eval_str har lagts till.

Ändrad i version 3.14: Parametern annotation_format har lagts till.

Anteckning

Vissa callables kanske inte är introspekterbara i vissa implementationer av Python. I CPython tillhandahåller till exempel vissa inbyggda funktioner som definieras i C inga metadata om sina argument.

Om det objekt som skickas har ett attribut __signature__ kan vi använda det för att skapa signaturen. Den exakta semantiken är en implementationsdetalj och kan komma att ändras utan förvarning. Se källkoden för aktuell semantik.

class inspect.Signature(parameters=None, *, return_annotation=Signature.empty)¶

Ett Signature-objekt representerar anropssignaturen för en funktion och dess returannotation. För varje parameter som accepteras av funktionen lagras ett Parameter-objekt i dess parameters-samling.

Det valfria argumentet parameters är en sekvens av Parameter-objekt, som valideras för att kontrollera att det inte finns några parametrar med duplicerade namn, och att parametrarna är i rätt ordning, dvs. först positional-only, sedan positional-or-keyword, och att parametrar med standardvärden följer parametrar utan standardvärden.

Det valfria return_annotation-argumentet kan vara ett godtyckligt Python-objekt. Det representerar ”return”-annoteringen för den anropbara funktionen.

Signature-objekt är föränderliga. Använd Signature.replace() eller copy.replace() för att göra en modifierad kopia.

Ändrad i version 3.5: Signature-objekt är nu plockbara och hashable.

empty¶: En speciell markör på klassnivå för att ange avsaknad av en returannotation.

parameters¶: En ordnad mappning av parameternamn till motsvarande Parameter-objekt. Parametrar visas i strikt definitionsordning, inklusive parametrar som endast innehåller nyckelord.

Ändrad i version 3.7: Python garanterade endast uttryckligen att deklarationsordningen för parametrar som endast innehåller nyckelord skulle bevaras från och med version 3.7, även om denna ordning i praktiken alltid hade bevarats i Python 3.

return_annotation¶: ”Return”-annoteringen för den anropbara funktionen. Om anropsbarheten inte har någon ”return”-annotation, sätts detta attribut till Signature.empty.

bind(*args, **kwargs)¶: Skapar en mappning från positions- och nyckelordsargument till parametrar. Returnerar BoundArguments om *args och **kwargs matchar signaturen, eller ger upphov till ett TypeError.

bind_partial(*args, **kwargs)¶: Fungerar på samma sätt som Signature.bind(), men tillåter utelämnande av vissa nödvändiga argument (efterliknar functools.partial() beteende.) Returnerar BoundArguments, eller ger upphov till ett TypeError om de passerade argumenten inte matchar signaturen.

replace(*[, parameters][, return_annotation])¶

Skapar en ny Signature-instans baserat på den instans som replace() anropades på. Det är möjligt att skicka olika parametrar och/eller return_annotation för att åsidosätta motsvarande egenskaper hos bassignaturen. För att ta bort return_annotation från den kopierade Signature, skicka in Signature.empty.

>>> def test(a, b):
...     pass
...
>>> sig = signature(test)
>>> new_sig = sig.replace(return_annotation="new return anno")
>>> str(new_sig)
"(a, b) -> 'new return anno'"

Signature-objekt stöds också av den generiska funktionen copy.replace().

format(*, max_width=None, quote_annotation_strings=True)¶

Skapa en strängrepresentation av objektet Signature.

Om max_width anges kommer metoden att försöka passa in signaturen på rader med högst max_width tecken. Om signaturen är längre än max_width kommer alla parametrar att stå på separata rader.

Om quote_annotation_strings är False visas annotations i signaturen utan inledande och avslutande citattecken om de är strängar. Detta är användbart om signaturen skapades med formatet STRING eller om from __future__ import annotations användes.

Tillagd i version 3.13.

Ändrad i version 3.14: Parametern unquote_annotations har lagts till.

classmethod from_callable(obj, *, follow_wrapped=True, globals=None, locals=None, eval_str=False)¶

Returnera ett Signature-objekt (eller dess underklass) för en given anropbar obj.

Denna metod förenklar underklassning av Signature:

class MySignature(Signature):
    pass
sig = MySignature.from_callable(sum)
assert isinstance(sig, MySignature)

Dess beteende är i övrigt identiskt med det för signature().

Tillagd i version 3.5.

Ändrad i version 3.10: Parametrarna globals, locals och eval_str har lagts till.

class inspect.Parameter(name, kind, *, default=Parameter.empty, annotation=Parameter.empty)¶

Parameter-objekt är föränderliga. Istället för att modifiera ett Parameter-objekt kan du använda Parameter.replace() eller copy.replace() för att skapa en modifierad kopia.

Ändrad i version 3.5: Parameterobjekt är nu picklbara och hashable.

empty¶: En särskild markör på klassnivå för att ange avsaknad av standardvärden och annoteringar.

name¶: Namnet på parametern som en sträng. Namnet måste vara en giltig Python-identifierare.

CPython genererar implicita parameternamn av formen .0 på de kodobjekt som används för att implementera förståelser och generatoruttryck.

Ändrad i version 3.6: Dessa parameternamn exponeras nu av denna modul som namn som implicit0.

default¶: Standardvärdet för parametern. Om parametern inte har något standardvärde, sätts detta attribut till Parameter.empty.

annotation¶: Annotationen för parametern. Om parametern inte har någon annotation, sätts detta attribut till Parameter.empty.

kind¶

Beskriver hur argumentvärden binds till parametern. De möjliga värdena är tillgängliga via Parameter (som Parameter.KEYWORD_ONLY), och stöder jämförelse och ordning, i följande ordning:

Namn	Betydelse
POSITIONAL_ONLY	Värdet måste anges som ett positionellt argument. Endast positionella parametrar är de som visas före en `/`-post (om sådan finns) i en Python-funktionsdefinition.
POSITIONAL_OR_KEYWORD	Värdet kan anges som antingen ett nyckelord eller ett positionellt argument (detta är standardbindningsbeteendet för funktioner som implementeras i Python)
VAR_POSITIONAL	En tupel av positionella argument som inte är bundna till någon annan parameter. Detta motsvarar en `*args`-parameter i en Python-funktionsdefinition.
KEYWORD_ONLY	Värdet måste anges som ett nyckelordsargument. Parametrar som endast innehåller nyckelord är de som visas efter en `` eller `args` post i en Python-funktionsdefinition.
VAR_KEYWORD	Ett dict med nyckelordsargument som inte är bundna till någon annan parameter. Detta motsvarar en `**kwargs`-parameter i en Python-funktionsdefinition.

Exempel: Skriv ut alla argument som bara innehåller nyckelord utan standardvärden:

>>> def foo(a, b, *, c, d=10):
...     pass

>>> sig = signature(foo)
>>> for param in sig.parameters.values():
...     if (param.kind == param.KEYWORD_ONLY and
...                        param.default is param.empty):
...         print('Parameter:', param)
Parameter: c

kind.description¶

Beskriver ett enumvärde av Parameter.kind.

Tillagd i version 3.8.

Exempel: Skriv ut alla beskrivningar av argument:

>>> def foo(a, b, *, c, d=10):
...     pass

>>> sig = signature(foo)
>>> for param in sig.parameters.values():
...     print(param.kind.description)
positional or keyword
positional or keyword
keyword-only
keyword-only

replace(*[, name][, kind][, default][, annotation])¶

Skapar en ny Parameter-instans baserat på den instans som replaced anropades på. För att åsidosätta ett Parameter-attribut, skicka motsvarande argument. För att ta bort ett standardvärde eller/och en annotering från en Parameter, skicka Parameter.empty.

>>> from inspect import Parameter
>>> param = Parameter('foo', Parameter.KEYWORD_ONLY, default=42)
>>> str(param)
'foo=42'

>>> str(param.replace()) # Will create a shallow copy of 'param'
'foo=42'

>>> str(param.replace(default=Parameter.empty, annotation='spam'))
"foo: 'spam'"

Parameter-objekt stöds också av den generiska funktionen copy.replace().

Ändrad i version 3.4: I Python 3.3 tilläts Parameter-objekt att ha name satt till None om deras kind var satt till POSITIONAL_ONLY. Detta är inte längre tillåtet.

class inspect.BoundArguments¶

Resultatet av ett anrop av Signature.bind() eller Signature.bind_partial(). Innehåller mappningen av argument till funktionens parametrar.

arguments¶

En föränderlig mappning av parameternamn till argumentvärden. Innehåller endast explicit bundna argument. Ändringar i arguments kommer att återspeglas i args och kwargs.

Bör användas tillsammans med Signature.parameters för eventuell bearbetning av argument.

Anteckning

Argument för vilka Signature.bind() eller Signature.bind_partial() förlitade sig på ett standardvärde hoppas över. Om det behövs kan du dock använda BoundArguments.apply_defaults() för att lägga till dem.

Ändrad i version 3.9: arguments är nu av typen dict. Tidigare var den av typen collections.OrderedDict.

args¶: En tupel av positionella argumentvärden. Dynamiskt beräknad från attributet arguments.

kwargs¶: Ett dict av nyckelordsargumentvärden. Beräknas dynamiskt från attributet arguments. Argument som kan skickas positionellt inkluderas i args istället.

signature¶: En referens till det överordnade Signature-objektet.

apply_defaults()¶

Ange standardvärden för saknade argument.

För variable-positional argument (*args) är standardvärdet en tom tupel.

För argument med nyckelord för variabler (**kwargs) är standardvärdet en tom dict.

>>> def foo(a, b='ham', *args): pass
>>> ba = inspect.signature(foo).bind('spam')
>>> ba.apply_defaults()
>>> ba.arguments
{'a': 'spam', 'b': 'ham', 'args': ()}

Tillagd i version 3.5.

Egenskaperna args och kwargs kan användas för att anropa funktioner:

def test(a, *, b):
    ...

sig = signature(test)
ba = sig.bind(10, b=20)
test(*ba.args, **ba.kwargs)

Se även

PEP 362 - Funktion Signatur Objekt.: Den detaljerade specifikationen, implementeringsdetaljer och exempel.

Klasser och funktioner¶

inspect.getclasstree(classes, unique=False)¶: Ordna den angivna listan över klasser i en hierarki av nästlade listor. Där en nästlad lista visas innehåller den klasser som härrör från den klass vars post omedelbart föregår listan. Varje post är en 2-tupel som innehåller en klass och en tupel av dess basklasser. Om argumentet unique är sant, visas exakt en post i den returnerade strukturen för varje klass i den angivna listan. I annat fall kommer klasser som använder multipel nedärvning och deras ättlingar att visas flera gånger.

inspect.getfullargspec(func)¶

Hämta namn och standardvärden för en Python-funktions parametrar. En namngiven tupel returneras:

FullArgSpec(args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations)

args är en lista med namn på positionella parametrar. varargs är namnet på parametern * eller None om godtyckliga positionella argument inte accepteras. varkw är namnet på parametern ** eller None om godtyckliga nyckelordsargument inte accepteras. defaults är en n-tupel av standardargumentvärden som motsvarar de sista n positionella parametrarna, eller None om inga sådana standardvärden har definierats. kwonlyargs är en lista med parameternamn som endast innehåller nyckelord i deklarationsordning. kwonlydefaults är en ordbok som mappar parameternamn från kwonlyargs till de standardvärden som används om inget argument anges. annotations är en ordbok som mappar parameternamn till annotations. Den speciella nyckeln "return" används för att rapportera funktionens returvärde (om någon).

Notera att signature() och Signature Object tillhandahåller det rekommenderade API:et för anropsbar introspektion och stödjer ytterligare beteenden (som enbart positionella argument) som ibland påträffas i API:er för tilläggsmoduler. Denna funktion behålls främst för användning i kod som behöver upprätthålla kompatibilitet med Python 2 inspect modul API.

Ändrad i version 3.4: Denna funktion är nu baserad på signature(), men ignorerar fortfarande __wrapped__-attribut och inkluderar den redan bundna första parametern i signaturutmatningen för bundna metoder.

Ändrad i version 3.6: Denna metod var tidigare dokumenterad som utfasad till förmån för signature() i Python 3.5, men det beslutet har återtagits för att återställa ett tydligt standardgränssnitt för Python 2/3-kod med en enda källa som migrerar bort från det äldre getargspec() API.

Ändrad i version 3.7: Python garanterade endast uttryckligen att deklarationsordningen för parametrar som endast innehåller nyckelord skulle bevaras från och med version 3.7, även om denna ordning i praktiken alltid hade bevarats i Python 3.

inspect.getargvalues(frame)¶: Hämta information om argument som skickas in i en viss frame. En named tuple ArgInfo(args, varargs, keywords, locals) returneras. args är en lista över argumentens namn. varargs och keywords är namnen på argumenten * och ** eller None. locals är locals-ordlistan för den givna ramen.

Anteckning

Denna funktion markerades oavsiktligt som föråldrad i Python 3.5.

inspect.formatargvalues(args[, varargs, varkw, locals, formatarg, formatvarargs, formatvarkw, formatvalue])¶: Formaterar en vacker argumentspecifikation från de fyra värden som returneras av getargvalues(). Argumenten format* är motsvarande valfria formateringsfunktioner som anropas för att omvandla namn och värden till strängar.

Anteckning

Denna funktion markerades oavsiktligt som föråldrad i Python 3.5.

inspect.getmro(cls)¶: Returnerar en tupel av klass cls basklasser, inklusive cls, i metodupplösningsordning. Ingen klass förekommer mer än en gång i denna tupel. Observera att metodupplösningsordningen beror på cls:s typ. Om inte en mycket märklig användardefinierad metatyp används, kommer cls att vara det första elementet i tupeln.

inspect.getcallargs(func, /, *args, **kwds)¶

Bind args och kwds till argumentnamnen i Python-funktionen eller -metoden func, som om den anropades med dem. För bundna metoder binds även det första argumentet (vanligtvis kallat self) till den associerade instansen. En dict returneras, som mappar argumentnamnen (inklusive namnen på argumenten * och **, om sådana finns) till deras värden från args och kwds. Om func anropas på fel sätt, dvs. när func(*args, **kwds) skulle ge upphov till ett undantag på grund av inkompatibel signatur, ges ett undantag av samma typ och med samma eller liknande meddelande. Ett exempel:

>>> from inspect import getcallargs
>>> def f(a, b=1, *pos, **named):
...     pass
...
>>> getcallargs(f, 1, 2, 3) == {'a': 1, 'named': {}, 'b': 2, 'pos': (3,)}
True
>>> getcallargs(f, a=2, x=4) == {'a': 2, 'named': {'x': 4}, 'b': 1, 'pos': ()}
True
>>> getcallargs(f)
Traceback (most recent call last):
...
TypeError: f() missing 1 required positional argument: 'a'

Tillagd i version 3.2.

Föråldrad sedan version 3.5: Använd Signature.bind() och Signature.bind_partial() istället.

inspect.getclosurevars(func)¶

Hämta mappningen av externa namnreferenser i en Python-funktion eller -metod func till deras aktuella värden. En named tuple ClosureVars(nonlocals, globals, builtins, unbound) returneras. nonlocals mappar refererade namn till lexikala stängningsvariabler, globals till funktionens modulglobaler och builtins till de builtins som är synliga från funktionens kropp. unbound är den uppsättning namn som refereras till i funktionen och som inte kunde lösas alls med tanke på de aktuella modulglobalerna och builtins.

TypeError uppstår om func inte är en Python-funktion eller -metod.

Tillagd i version 3.3.

inspect.unwrap(func, *, stop=None)¶

Hämta objektet som är inlindat av func. Den följer kedjan av __wrapped__-attribut och returnerar det sista objektet i kedjan.

stop är en valfri callback som accepterar ett objekt i omslagskedjan som sitt enda argument och som gör att uppackningen kan avslutas i förtid om callbacken returnerar ett sant värde. Om callbacken aldrig returnerar ett sant värde returneras det sista objektet i kedjan som vanligt. Till exempel använder signature() detta för att stoppa uppackningen om något objekt i kedjan har ett __signature__-attribut definierat.

ValueError utlöses om en cykel påträffas.

Tillagd i version 3.4.

inspect.get_annotations(obj, *, globals=None, locals=None, eval_str=False, format=annotationlib.Format.VALUE)¶

Beräkna annoteringsdikten för ett objekt.

Detta är ett alias för annotationlib.get_annotations(); se dokumentationen för den funktionen för mer information.

Tillagd i version 3.10.

Ändrad i version 3.14: Den här funktionen är nu ett alias för annotationlib.get_annotations(). Att anropa den som inspect.get_annotations kommer att fortsätta att fungera.

Tolkens stack¶

Några av följande funktioner returnerar FrameInfo-objekt. För bakåtkompatibilitet tillåter dessa objekt tuple-liknande operationer på alla attribut utom positions. Detta beteende anses vara föråldrat och kan komma att tas bort i framtiden.

class inspect.FrameInfo¶

frame¶: Den ramobjekt som posten motsvarar.

filename¶: Filnamnet som associeras med den kod som körs av den ram som denna post motsvarar.

lineno¶: Radnumret på den aktuella raden som är kopplad till den kod som körs av den ram som denna post motsvarar.

function¶: Namnet på den funktion som utförs av den ram som denna post motsvarar.

code_context¶: En lista med kontextrader från källkoden som exekveras av den ram som den här posten motsvarar.

index¶: Index för den aktuella raden som körs i listan code_context.

positions¶: Ett dis.Positions-objekt som innehåller startradenummer, slutradenummer, startkolumnförskjutning och slutkolumnförskjutning som är associerade med den instruktion som utförs av den ram som denna post motsvarar.

Ändrad i version 3.5: Returnera en named tuple istället för en tuple.

Ändrad i version 3.11: FrameInfo är nu en klassinstans (som är bakåtkompatibel med den tidigare named tuple).

class inspect.Traceback¶

filename¶: Filnamnet som är associerat med koden som körs av den ram som denna traceback motsvarar.

lineno¶: Radnumret för den aktuella raden som är kopplad till den kod som körs av den ram som denna traceback motsvarar.

function¶: Funktionsnamnet som exekveras av den ram som denna traceback motsvarar.

code_context¶: En lista med kontextrader från källkoden som exekveras av den ram som denna traceback motsvarar.

index¶: Index för den aktuella raden som körs i listan code_context.

positions¶: Ett dis.Positions-objekt som innehåller startradnummer, slutradnummer, startkolumnförskjutning och slutkolumnförskjutning som är associerade med den instruktion som utförs av den ram som denna traceback motsvarar.

Ändrad i version 3.11: Traceback är nu en klassinstans (som är bakåtkompatibel med den tidigare named tuple).

Anteckning

Om man behåller referenser till ramobjekt, som finns i det första elementet i de ramposter som dessa funktioner returnerar, kan det leda till att programmet skapar referenscykler. När en referenscykel har skapats kan livslängden för alla objekt som kan nås från de objekt som bildar cykeln bli mycket längre, även om Pythons valfria cykeldetektor är aktiverad. Om sådana cykler måste skapas är det viktigt att se till att de uttryckligen bryts för att undvika den fördröjda förstörelsen av objekt och den ökade minnesförbrukning som uppstår.

Även om cykeldetektorn kommer att fånga upp dessa, kan förstörelsen av ramarna (och lokala variabler) göras deterministisk genom att ta bort cykeln i en finally-sats. Detta är också viktigt om cykeldetektorn var inaktiverad när Python kompilerades eller med gc.disable(). Till exempel:

def handle_stackframe_without_leak():
    frame = inspect.currentframe()
    try:
        # do something with the frame
    finally:
        del frame

Om du vill behålla ramen (t.ex. för att skriva ut en traceback senare) kan du också bryta referenscykler genom att använda metoden frame.clear().

Det valfria argumentet context som stöds av de flesta av dessa funktioner anger antalet rader med kontext som ska returneras, vilka är centrerade runt den aktuella raden.

inspect.getframeinfo(frame, context=1)¶: Hämta information om en ram eller ett traceback-objekt. Ett Traceback-objekt returneras.

Ändrad i version 3.11: Ett Traceback-objekt returneras istället för en namngiven tupel.

inspect.getouterframes(frame, context=1)¶: Hämta en lista med FrameInfo-objekt för en ram och alla yttre ramar. Dessa ramar representerar de anrop som leder till skapandet av frame. Den första posten i den returnerade listan representerar frame; den sista posten representerar det yttersta anropet på frame:s stack.

Ändrad i version 3.5: En lista med namngivna tupler FrameInfo(frame, filename, lineno, function, code_context, index) returneras.

Ändrad i version 3.11: En lista med FrameInfo-objekt returneras.

inspect.getinnerframes(traceback, context=1)¶: Hämta en lista med FrameInfo-objekt för en tracebacks ram och alla inre ramar. Dessa ramar representerar anrop som görs som en konsekvens av frame. Den första posten i listan representerar traceback; den sista posten representerar var undantaget uppstod.

Ändrad i version 3.5: En lista med namngivna tupler FrameInfo(frame, filename, lineno, function, code_context, index) returneras.

Ändrad i version 3.11: En lista med FrameInfo-objekt returneras.

inspect.currentframe()¶: Returnerar ramobjektet för anroparens stackram.

Denna funktion förlitar sig på Python stack frame-stöd i tolken, vilket inte garanterat finns i alla implementationer av Python. Om den körs i en implementering utan stöd för Python stack frame returnerar denna funktion None.

inspect.stack(context=1)¶: Returnerar en lista med FrameInfo-objekt för anroparens stack. Den första posten i den returnerade listan representerar anroparen; den sista posten representerar det yttersta anropet på stacken.

Ändrad i version 3.5: En lista med namngivna tupler FrameInfo(frame, filename, lineno, function, code_context, index) returneras.

Ändrad i version 3.11: En lista med FrameInfo-objekt returneras.

inspect.trace(context=1)¶: Returnerar en lista med FrameInfo-objekt för stacken mellan den aktuella ramen och den ram i vilken ett undantag som för närvarande hanteras uppstod. Den första posten i listan representerar anroparen; den sista posten representerar var undantaget uppstod.

Ändrad i version 3.5: En lista med namngivna tupler FrameInfo(frame, filename, lineno, function, code_context, index) returneras.

Ändrad i version 3.11: En lista med FrameInfo-objekt returneras.

Hämta attribut statiskt¶

Både getattr() och hasattr() kan utlösa kodexekvering när de hämtar eller kontrollerar om attribut finns. Deskriptorer, som egenskaper, kommer att anropas och __getattr__() och __getattribute__() kan anropas.

För fall där du vill ha passiv introspektion, som dokumentationsverktyg, kan detta vara obekvämt. getattr_static() har samma signatur som getattr() men undviker att exekvera kod när den hämtar attribut.

inspect.getattr_static(obj, attr, default=None)¶

Hämta attribut utan att utlösa dynamisk uppslagning via descriptor-protokollet, __getattr__() eller __getattribute__().

Observera: den här funktionen kanske inte kan hämta alla attribut som getattr kan hämta (t.ex. dynamiskt skapade attribut) och kan hitta attribut som getattr inte kan (t.ex. beskrivningar som ger AttributeError). Den kan också returnera deskriptorobjekt i stället för instansmedlemmar.

Om instansen __dict__ skuggas av en annan medlem (t.ex. en egenskap) kommer denna funktion inte att kunna hitta instansmedlemmar.

Tillagd i version 3.2.

getattr_static() löser inte deskriptorer, t.ex. slotdeskriptorer eller getsetdeskriptorer på objekt som implementerats i C. Deskriptorobjektet returneras i stället för det underliggande attributet.

Du kan hantera dessa med kod som följande. Observera att för godtyckliga getset-beskrivare kan anrop av dessa utlösa kodkörning:

# example code for resolving the builtin descriptor types
class _foo:
    __slots__ = ['foo']

slot_descriptor = type(_foo.foo)
getset_descriptor = type(type(open(__file__)).name)
wrapper_descriptor = type(str.__dict__['__add__'])
descriptor_types = (slot_descriptor, getset_descriptor, wrapper_descriptor)

result = getattr_static(some_object, 'foo')
if type(result) in descriptor_types:
    try:
        result = result.__get__()
    except AttributeError:
        # descriptors can raise AttributeError to
        # indicate there is no underlying value
        # in which case the descriptor itself will
        # have to do
        pass

Aktuellt läge för generatorer, coroutines och asynkrona generatorer¶

När man implementerar coroutine-schemaläggare och för andra avancerade användningar av generatorer är det användbart att avgöra om en generator körs för närvarande, väntar på att starta eller återuppta körningen eller redan har avslutats. getgeneratorstate() gör det enkelt att avgöra en generators aktuella tillstånd.

inspect.getgeneratorstate(generator)¶

Hämta aktuellt tillstånd för en generator-iterator.

Möjliga tillstånd är:

GEN_CREATED: Väntar på att starta exekvering.
GEN_RUNNING: Exekveras för närvarande av tolken.
GEN_SUSPENDED: För närvarande suspenderad vid ett yield-uttryck.
GEN_CLOSED: Exekveringen har slutförts.

Tillagd i version 3.2.

inspect.getcoroutinestate(coroutine)¶

Hämta aktuellt tillstånd för ett coroutine-objekt. Funktionen är avsedd att användas med coroutine-objekt som skapats av async def-funktioner, men accepterar alla coroutine-liknande objekt som har attributen cr_running och cr_frame.

Möjliga tillstånd är:

CORO_CREATED: Väntar på att starta exekvering.
CORO_RUNNING: Exekveras för närvarande av tolken.
CORO_SUSPENDED: För närvarande avbruten vid ett await-uttryck.
CORO_CLOSED: Exekveringen har slutförts.

Tillagd i version 3.5.

inspect.getasyncgenstate(agen)¶

Hämta aktuellt tillstånd för ett asynkront generatorobjekt. Funktionen är avsedd att användas med asynkrona iteratorobjekt som skapats av async def-funktioner som använder yield-satsen, men accepterar alla asynkrona generatorliknande objekt som har attributen ag_running och ag_frame.

Möjliga tillstånd är:

AGEN_CREATED: Väntar på att starta körning.
AGEN_RUNNING: Exekveras för närvarande av tolken.
AGEN_SUSPENDED: För närvarande suspenderad vid ett yield-uttryck.
AGEN_CLOSED: Exekveringen har slutförts.

Tillagd i version 3.12.

Generatorns aktuella interna tillstånd kan också efterfrågas. Detta är mest användbart för teständamål, för att säkerställa att det interna tillståndet uppdateras som förväntat:

inspect.getgeneratorlocals(generator)¶

Hämta mappningen av live lokala variabler i generator till deras aktuella värden. En ordbok returneras som mappar från variabelnamn till värden. Detta är likvärdigt med att anropa locals() i generatorns kropp, och alla samma varningar gäller.

Om generator är en generator utan någon associerad ram returneras en tom ordbok. TypeError uppstår om generator inte är ett Python generator-objekt.

Denna funktion förlitar sig på att generatorn exponerar en Python-stackram för introspektion, vilket inte garanterat är fallet i alla implementationer av Python. I sådana fall kommer denna funktion alltid att returnera en tom ordbok.

Tillagd i version 3.3.

inspect.getcoroutinelocals(coroutine)¶: Denna funktion är analog med getgeneratorlocals(), men fungerar för coroutine-objekt som skapats av async def-funktioner.

Tillagd i version 3.5.

inspect.getasyncgenlocals(agen)¶: Denna funktion är analog med getgeneratorlocals(), men fungerar för asynkrona generatorobjekt som skapats av async def-funktioner som använder yield-satsen.

Tillagd i version 3.12.

Kodobjekt Bit Flaggor¶

Python-kodobjekt har ett co_flags-attribut, som är en bitmapp av följande flaggor:

inspect.CO_OPTIMIZED¶: Kodobjektet är optimerat och använder snabba lokala enheter.

inspect.CO_NEWLOCALS¶: Om den är inställd kommer en ny dict att skapas för ramens f_locals när kodobjektet exekveras.

inspect.CO_VARARGS¶: Kodobjektet har en variabel positionell parameter (*args-liknande).

inspect.CO_VARKEYWORDS¶: Kodobjektet har en variabel nyckelordsparameter (**kwargs-liknande).

inspect.CO_NESTED¶: Flaggan sätts när kodobjektet är en nästlad funktion.

inspect.CO_GENERATOR¶: Flaggan sätts när kodobjektet är en generatorfunktion, d.v.s. ett generatorobjekt returneras när kodobjektet exekveras.

inspect.CO_COROUTINE¶: Flaggan sätts när kodobjektet är en coroutine-funktion. När kodobjektet exekveras returnerar det ett coroutine-objekt. Se PEP 492 för mer information.

Tillagd i version 3.5.

inspect.CO_ITERABLE_COROUTINE¶: Flaggan används för att omvandla generatorer till generatorbaserade coroutines. Generatorobjekt med denna flagga kan användas i await-uttryck och kan yield from coroutine-objekt. Se PEP 492 för mer information.

Tillagd i version 3.5.

inspect.CO_ASYNC_GENERATOR¶: Flaggan sätts när kodobjektet är en asynkron generatorfunktion. När kodobjektet exekveras returnerar det ett asynkront generatorobjekt. Se PEP 525 för mer information.

Tillagd i version 3.6.

inspect.CO_HAS_DOCSTRING¶: Flaggan sätts när det finns en docstring för kodobjektet i källkoden. Om den är satt kommer den att vara den första posten i co_consts.

Tillagd i version 3.14.

inspect.CO_METHOD¶: Flaggan sätts när kodobjektet är en funktion som definieras i klassomfånget.

Tillagd i version 3.14.

Anteckning

Flaggorna är specifika för CPython och kanske inte definieras i andra Python-implementationer. Dessutom är flaggorna en implementationsdetalj och kan tas bort eller föråldras i framtida Python-utgåvor. Det rekommenderas att använda offentliga API:er från modulen inspect för alla introspektionsbehov.

Buffertflaggor¶

class inspect.BufferFlags¶

Detta är en enum.IntFlag som representerar de flaggor som kan skickas till __buffer__()-metoden för objekt som implementerar buffer protocol.

Betydelsen av flaggorna förklaras i Typer av buffertförfrågningar.

SIMPLE¶

WRITABLE¶

FORMAT¶

ND¶

STRIDES¶

C_CONTIGUOUS¶

F_CONTIGUOUS¶

ANY_CONTIGUOUS¶

INDIRECT¶

CONTIG¶

CONTIG_RO¶

STRIDED¶

STRIDED_RO¶

RECORDS¶

RECORDS_RO¶

FULL¶

FULL_RO¶

READ¶

WRITE¶

Tillagd i version 3.12.

Kommandoradsgränssnitt¶

Modulen inspect ger också en grundläggande möjlighet till introspektion från kommandoraden.

Accepterar som standard namnet på en modul och skriver ut källan till den modulen. En klass eller funktion inom modulen kan skrivas ut istället genom att lägga till ett kolon och det kvalificerade namnet på målobjektet.

--details¶: Skriv ut information om det angivna objektet i stället för källkoden

`inspect` — Inspektera live-objekt¶

Typer och medlemmar¶

Hämtning av källkod¶

Introspektering av anropsbara objekt med signaturobjektet¶

Klasser och funktioner¶

Tolkens stack¶

Hämta attribut statiskt¶

Aktuellt läge för generatorer, coroutines och asynkrona generatorer¶

Kodobjekt Bit Flaggor¶

Buffertflaggor¶

Kommandoradsgränssnitt¶

Innehåll

Föregående ämne

Nästa ämne

Denna sidan

inspect — Inspektera live-objekt¶

Typer och medlemmar¶

Hämtning av källkod¶

Introspektering av anropsbara objekt med signaturobjektet¶

Klasser och funktioner¶

Tolkens stack¶

Hämta attribut statiskt¶

Aktuellt läge för generatorer, coroutines och asynkrona generatorer¶

Kodobjekt Bit Flaggor¶

Buffertflaggor¶

Kommandoradsgränssnitt¶

`inspect` — Inspektera live-objekt¶