Python-inspeksjonsmodul

Oversikt

Noen gang lurt på hvor kult det ville være å ha makten til å faktisk få kildekoden til en annen Python-modul i ditt eget program? Dette vil åpne ideer og dører til så mange muligheter som å behandle kildekoden til en modul, få dokstring, produsere dokumentasjon for et stykke kode automatisk. La meg fortelle deg at dette er 100% mulig med Pythons undersøke modul.

Python-inspeksjonsmodul

Python undersøke modul lar oss inspisere objekter i et løpende program, få kildekoden til en modul, få dokstringen tilknyttet den modulen, lese metodesignaturen til en funksjon i Python og mye mer. På denne måten kan vi bygge prosjekter som produserer live kodedokumentasjon for våre egne prosjekter. Dette betyr at vi bare trenger å gi nødvendige kommentarer til Python-koden vår, og vi kan overlate resten av jobben til Python selv for å produsere dokumentasjonen for oss.

Bruke eksempelkode

For å forstå hvordan Python er undersøke modulen fungerer, vil vi bruke en av våre egne eksempler på definisjon i Python, som bare viser arv i Python og hvordan objekter blir laget. La oss se på eksempelmodulen vi skal bruke i resten av opplæringen her:

def module_level_function (arg1, arg2 = 'default', * args):
"" "Jeg er en funksjon på modulnivå."" "
local_var = arg1 * 2
returner local_var
klasse Person (objekt):
"" "Definisjon for personklasse."" "
def __init __ (selv, navn):
selv-.navn = navn
def get_name (selv):
"Returnerer navnet på forekomsten."
tilbake selv.Navn
person_obj = Person ('sample_instance')
klasse Student (person):
"" "Dette er studentklassen, barn av personklassen.
"" "
# Denne metoden er ikke en del av Person-klassen.
def do_something_else (selv):
Alt kan gjøres her."" "
def get_name (selv):
"Overstyrer versjonen fra personklassen"
returner 'Student (' + selv.navn + ')'

Vi har definert en eksempelmodul slik at vi kan begynne å trekke ut kildekoden og andre komponenter fra den i senere eksempler vi skriver. La oss komme i gang.

Inspeksjonsmodul

Ovennevnte Python-modul lagres i en fil som heter linuxhint.py i samme katalog der vi skal lage våre nye Python-skript. Vi kan inspisere en modul i Python ved først å importere den. Denne importerklæringen vil også være tilstede i alle skriptene vi skriver i senere seksjoner. Her er et eksempelprogram som vi inspiserer modulen vår med:

import inspisere
importer linuxhint
for navn, data i inspeksjon.getmembers (linuxhint):
hvis navn.begynner med('__'):
Fortsette
skrive ut(' : !r '.format (navn, data))

Her er hva vi kommer tilbake med denne kommandoen:

Python-inspeksjonsmodul

Utgangen gir oss detaljene om hvor mange klasser, funksjoner og objekter som finnes i denne modulen når skriptet kjøres.

Inspisere klasser i en modul

Ovenstående eksempel vi viste presenterte alle detaljer i en modul på en gang. hvis vi bare vil få informasjonen knyttet til klassene i modulen, kan vi få det samme som:

import inspisere
importer linuxhint
for nøkkel, data i inspeksjon.getmembers (linuxhint, inspect.isklasse):
skrive ut(' : !r '.format (nøkkel, data))

La oss se utdataene for denne kommandoen:

Python inspisere modul klasse

Resultatet er nøyaktig det samme, bare at denne gangen ble bare klassedefinisjonene skrevet ut på konsollen.

Inspisere metoder i en klasse

Metodene er den som definerer oppførselen til en klasse i OOP og gir informasjon om hvordan en Objekters atferd vil bli endret etter hvert som metodene blir påkalt dem. Det er på grunn av dette at det er viktig å dokumentere alle metodene som finnes i en klasse eller en modul. Vi kan få informasjon relatert til en metode som denne:

import inspisere
fra pprint import pprint
importer linuxhint
pprint (inspiser.getmembers (linuxhint.Person, inspiser.er funksjon))

Her er hva vi kommer tilbake med denne kommandoen:

Inspisere en klassemetode

Utgangen viser bare metodedefinisjonen for hver metode som er tilstede.

Inspisere gjenstander fra en klasse

Når du introspekterer hvor mye plass som er opptatt når vi kjører et Python-skript, er det viktig å vite hvor mange objekter for klassen som er instantiert for klassen i et program. For å vite dette kan vi også få informasjon om objekter fra en klasse i en modul:

import inspisere
fra pprint import pprint
importer linuxhint
person = linuxhint.Person (name = 'inspect_getmembers')
pprint (inspiser.getmembers (person, inspiser.ismetode))

La oss se utdataene for denne kommandoen:

Inspisere gjenstander i klassen

Dette skriver også ut minneadressen der dette objektet bor i løpet av dette programmet.

Inspisere Docstring i en klasse

Doktringen av en modul er den delen som faktisk informerer en bruker eller en utvikler om at hva denne modulen handler om og hvilke funksjoner den gir. Med inspeksjonsmodulen kan vi få dokumentasjonen til en komplett modul for å dokumentere den bedre. La oss se hvordan vi kan trekke ut dokstring for en klasse:

import inspisere
importer linuxhint
utskrift ('Person.__doc__: ')
skriv ut (linuxhint.Person.__doc__)
skrive ut()
skriv ut ('getdoc (Person):')
skriv ut (inspiser.getdoc (linuxhint.Person))

Her er hva vi kommer tilbake med denne kommandoen:

Få Docstring til klassen

Inspisere kilde til en klasse

Til slutt kan vi se hvordan vi også kan trekke ut fullstendig kildekode for en klasse i et Python-program. Dette er en viktig funksjon så vel som dette hjelper oss med å bygge dokumentasjonsverktøy om en Python-modul. La oss se et eksempel i aksjon:

import inspisere
importer linuxhint
skriv ut (inspiser.getsource (linuxhint.Student))

Her er hva vi kommer tilbake med denne kommandoen:

Få kildekode for klassen

Inspisere kilde til en metode

På samme måte som vi hentet kildekoden til en klasse, vil vi nå trekke ut kildekoden til en metode i vårt Python-program:

import inspisere
importer linuxhint
skriv ut (inspiser.getsource (linuxhint.Student.get_name))

Her er hva vi kommer tilbake med denne kommandoen:

Få metode for kilde i en klasse

Inspeksjonsmetode Signatur

Signaturen til en metode gir et dypt innblikk i hva en metode gjør og hvilke input det tar. Det gir oss muligheten til å dokumentere en metode bedre fordi dokumentasjonen av en metode er ufullstendig uten å vite hvilket input det tar. Slik kan vi trekke ut informasjonen knyttet til en metodesignatur:

import inspisere
importer linuxhint
skriv ut (inspiser.signatur (linuxhint.module_level_function))

Her er hva vi kommer tilbake med denne kommandoen:

Få signatur av en metode

Konklusjon

I denne leksjonen så vi på hvordan vi kan bruke Python-inspeksjonsmodulen til å se på kildekoden og mange andre interne funksjoner i et Python-program. Les flere Python-baserte innlegg her.