Python-inspektionsmodul

Översikt

Någonsin undrat hur coolt det skulle vara att ha makten att faktiskt få källkoden till någon annan Python-modul i ditt eget program? Detta kommer att öppna idéer och dörrar till så många möjligheter som att bearbeta källkoden för en modul, få sin dokstring, producera dokumentation för en kodkod automatiskt. Låt mig säga dig, det här är 100% möjligt med Pythons inspektera modul.

Python-inspektionsmodul

Pytonorm inspektera Modulen låter oss inspektera objekt i ett pågående program, hämta källkoden till en modul, få docstring associerad med den modulen, läsa metodens signatur för en funktion i Python och mycket mer. På så sätt kan vi bygga projekt som producerar live koddokumentation för våra egna projekt. Det betyder att vi bara behöver göra nödvändiga kommentarer om vår Python-kod och vi kan lämna resten av jobbet till Python själv för att producera dokumentationen åt oss.

Använda exempelkod

För att förstå hur Python är inspektera modulen fungerar kommer vi att använda en av våra egna exempelkodsdefinitioner i Python som bara visar arv i Python och hur objekt görs. Låt oss titta på exempelmodulen vi kommer att använda i resten av handledningen här:

def module_level_function (arg1, arg2 = 'default', * args):
"" "Jag är en modulnivåfunktion."" "
local_var = arg1 * 2
returnera local_var
klass Person (objekt):
"" "Definition för personklass."" "
def __init __ (själv, namn):
själv.namn = namn
def get_name (själv):
"Returnerar namnet på förekomsten."
återvänd själv.namn
person_obj = Person ('sample_instance')
klass Student (person):
"" "Detta är studentklassen, barn till personklassen.
"" "
# Den här metoden ingår inte i personklassen.
def do_something_else (själv):
Allt kan göras här."" "
def get_name (själv):
"Åsidosätter version från personklass"
returnera 'Student (' + själv.namn + ')'

Vi har definierat en exempelmodul så att vi kan börja extrahera källkoden och andra komponenter från den i senare exempel vi skriver. Låt oss börja.

Inspektionsmodul

Ovanstående Python-modul sparas i en fil som heter linuxhint.py i samma katalog där vi kommer att göra våra nya Python-skript. Vi kan inspektera en modul i Python genom att först importera den. Detta importförklaring kommer också att finnas i alla skript som vi skriver i senare avsnitt. Här är ett exempelprogram som vi inspekterar vår modul med:

import inspektera
importera linuxhint
för namn, uppgifter i inspektion.getmembers (linuxhint):
om namn.börjar med('__'):
Fortsätta
skriva ut (': !r '.format (namn, data))

Här är vad vi får tillbaka med det här kommandot:

Python-inspektionsmodul

Utgången ger oss detaljer om hur många klasser, funktioner och objekt som finns i den här modulen när manuset körs.

Inspektera klasser i en modul

Ovanstående exempel vi visade presenterade alla detaljer i en modul på en gång. om vi bara vill få informationen relaterad till klasserna i modulen kan vi få samma som:

import inspektera
importera linuxhint
för nyckel, data under inspektion.getmembers (linuxhint, inspektera.isklass):
skriva ut (': !r '.format (nyckel, data))

Låt oss se utdata för det här kommandot:

Python-inspektionsmodulklass

Resultatet är exakt detsamma, bara att den här gången skrivs bara klassdefinitionerna ut på konsolen.

Inspektera metoder i en klass

Metoderna är de som definierar beteendet hos en klass i OOP och ger information om hur ett Objektbeteende kommer att modifieras eftersom metoderna kallas på dem. Det är därför det är viktigt att dokumentera alla metoder som finns i en klass eller en modul. Vi kan få information relaterad till en metod som denna:

import inspektera
från pprint import pprint
importera linuxhint
pprint (inspektera.getmembers (linuxhint.Person, inspektera.är funktion))

Här är vad vi får tillbaka med det här kommandot:

Inspektera en klassmetod

Utgången visar bara metoddefinitionen för varje närvarande metod.

Inspektera objekt i en klass

När du introspekterar hur mycket utrymme som är upptaget när vi kör ett Python-skript är det viktigt att veta hur många objekt för klassen som är instanserade för klassen i ett program. För att veta detta kan vi också få information om objekt i en klass i en modul:

import inspektera
från pprint import pprint
importera linuxhint
person = linuxhint.Person (name = 'inspect_getmembers')
pprint (inspektera.getmembers (person, inspektera.ismetod))

Låt oss se utdata för det här kommandot:

Inspektera objekt i klassen

Detta skriver också ut minnesadressen där objektet bor under detta program.

Inspektera Docstring i en klass

Doktringen av en modul är den del som faktiskt informerar en användare eller en utvecklare om att den här modulen handlar om och vilka funktioner den ger. Med inspektionsmodulen kan vi få docstring av en komplett modul för att dokumentera den bättre. Låt oss se hur vi kan extrahera docstring för en klass:

import inspektera
importera linuxhint
skriva ut ('Person.__doc__: ')
skriva ut (linuxhint.Person.__doc__)
skriva ut()
skriv ut ('getdoc (Person):')
skriva ut (inspektera.getdoc (linuxhint.Person))

Här är vad vi får tillbaka med det här kommandot:

Få Docstring för lektionen

Inspektera källan till en klass

Slutligen kan vi se hur vi också kan extrahera hela källkoden för en klass i ett Python-program. Detta är en viktig funktion såväl som detta hjälper oss att bygga dokumentationsverktyg om en Python-modul. Låt oss se ett exempel i aktion:

import inspektera
importera linuxhint
skriva ut (inspektera.getsource (linuxhint.Studerande))

Här är vad vi får tillbaka med det här kommandot:

Få källkod för klass

Inspektera källan till en metod

På samma sätt som vi extraherade källkoden för en klass kommer vi nu att extrahera källkoden för en metod i vårt Python-program:

import inspektera
importera linuxhint
skriva ut (inspektera.getsource (linuxhint.Studerande.hämta namn))

Här är vad vi får tillbaka med det här kommandot:

Få metodkälla i en klass

Inspektionsmetods underskrift

Signaturen av en metod ger en djup insikt om vad en metod gör och vilken input som krävs. Det ger oss möjlighet att dokumentera en metod bättre eftersom dokumentationen av en metod är ofullständig utan att veta vilken input det tar. Så här kan vi extrahera informationen relaterad till en metodsignatur:

import inspektera
importera linuxhint
skriva ut (inspektera.signatur (linuxhint.module_level_function))

Här är vad vi får tillbaka med det här kommandot:

Att få signatur för en metod

Slutsats

I den här lektionen tittade vi på hur vi kan använda Python-inspektionsmodulen för att titta på källkoden och många andra interna funktioner i ett Python-program. Läs mer Python-baserade inlägg här.