Python inspiser modul

Oversikt

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

Python inspiser modul

Python undersøke Modul lar oss inspisere objekter i et løpsprogram, få kildekoden til en modul, få doktoren tilknyttet den modulen, les metodesignaturen til en funksjon i Python og mye mer. På denne måten kan vi bygge prosjekter som produserer dokumentasjon av live -kode for våre egne prosjekter. Dette betyr at vi bare trenger å komme med nødvendige kommentarer til Python -koden vår, og vi kan forlate resten av jobben til Python selv for å produsere dokumentasjonen for oss.

Bruke prøvekode

Å forstå hvordan Python er undersøke Modul fungerer, vi vil bruke en av vår egen prøvekodedefinisjon i Python som bare demonstrerer arv i Python og hvordan objekter er laget. La oss se på prøvemodulen vi bruker i resten av opplæringen her:

def module_level_function (arg1, arg2 = 'standard', *args):
"" "Jeg er en funksjonsnivåfunksjon."" "
local_var = arg1 * 2
Returner local_var
Klasseperson (objekt):
"" "Definisjon for personklasse."" "
def __init __ (selv, navn):
selv-.Navn = Navn
def get_name (self):
"Returnerer navnet på forekomsten.""
Returnerer selv.Navn
Person_obj = Person ('Sample_Instance')
Klassestudent (person):
"" "Dette er studentklassen, Child of Person Class.
"" "
# Denne metoden er ikke en del av personklassen.
def do_something_else (selv):
"" "Alt kan gjøres her."" "
def get_name (self):
"Overskriver versjon fra personklasse"
Returner 'Student (' + selv.Navn + ')'

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

Inspisere modulen

Ovennevnte Python -modulen lagres i en fil som heter Linuxhint.py I samme katalog der vi lager våre nye Python -skript. Vi kan inspisere en modul i Python ved først å lage en import for den. Denne importuttalelsen vil også være til stede i alle skript vi skriver i senere seksjoner. Her er et eksempelprogram som vi inspiserer modulen vår:

Importer inspiser
Importer Linuxhint
For navn, data i inspeksjon.GetMembers (Linuxhint):
Hvis navn.begynner med('__'):
Fortsette
skrive ut(' : !r '.Format (navn, data))

Dette er hva vi kommer tilbake med denne kommandoen:

Python inspiser modul

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

Eksemplet ovenfor viste vi presenterte alle detaljer om en modul på en gang. Hvis vi bare ønsker å få informasjonen relatert til klassene i modulen, kan vi få den samme som:

Importer inspiser
Importer Linuxhint
For nøkkel, data i inspeksjon.GetMembers (Linuxhint, inspiser.ISClass):
skrive ut(' : !r '.Format (tast, data))

La oss se utdataene for denne kommandoen:

Python inspiser modulklasse

Utgangen er nøyaktig den samme, bare at bare klassedefinisjonene ble skrevet ut til konsollen.

Inspisere metoder i en klasse

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

Importer inspiser
Fra Pprint Import Pprint
Importer Linuxhint
Pprint (inspiser.GetMembers (Linuxhint.Person, inspiser.isfunksjon))

Dette er hva vi kommer tilbake med denne kommandoen:

Inspisere en metode for klassen

Utgangen viser bare metodedefinisjonen av hver metode som er til stede.

Inspisere gjenstander av en klasse

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

Importer inspiser
Fra Pprint Import Pprint
Importer Linuxhint
Person = Linuxhint.Person (name = 'Inspect_getMembers')
Pprint (inspiser.GetMembers (person, inspiser.isMethod))

La oss se utdataene for denne kommandoen:

Inspisere objekter av klassen

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

Inspiserer DocString av en klasse

Doktoren av en modul er den delen som faktisk informerer en bruker eller en utvikler om at denne modulen handler om og hvilke funksjoner gjør den gir. Med Inspect Module kan vi få doktoren til en komplett modul for å dokumentere den bedre. La oss se hvordan vi kan trekke ut Docstring for en klasse:

Importer inspiser
Importer Linuxhint
trykk ('person.__doc__: ')
Trykk (Linuxhint.Person.__doc__)
skrive ut()
trykk ('getDoc (person):')
trykk (inspiser.GetDoc (Linuxhint.Person))

Dette er hva vi kommer tilbake med denne kommandoen:

Få DocString for klassen

Inspisere kilden til en klasse

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

Importer inspiser
Importer Linuxhint
trykk (inspiser.GetSource (Linuxhint.Student))

Dette er hva vi kommer tilbake med denne kommandoen:

Få klassekode for klassen

Inspisere kilden til en metode

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

Importer inspiser
Importer Linuxhint
trykk (inspiser.GetSource (Linuxhint.Student.get_name)))

Dette er hva vi kommer tilbake med denne kommandoen:

Få kilde til metode i en klasse

Inspisere metodesignatur

Signaturen til en metode gir en dyp innsikt om hva en metode gjør og hvilke innspill som trengs. Det gir oss kraften til å dokumentere en metode bedre fordi dokumentasjon av en metode er ufullstendig uten å vite hvilke innspill tar det. Slik kan vi trekke ut informasjonen relatert til en metodesignatur:

Importer inspiser
Importer Linuxhint
trykk (inspiser.Signatur (Linuxhint.module_level_function))

Dette er hva vi kommer tilbake med denne kommandoen:

Få signatur av en metode

Konklusjon

I denne leksjonen så vi på hvordan vi kan benytte oss av Python Inspect Module for å se på kildekode og mange andre interne funksjoner i et Python -program. Les mer Python -baserte innlegg her.