02\x00r\xb9\x00d'
        b'\x12\x00Sd\x13\x00S',
        constants=(None, '\x87', '\x9a', '\x92', '\x8e', '\x8b', '\x85', '\x96', '\x81',
         '\x95', '\x84', '\x94', '\x8a', '\x83', '\x90', '\x8f', 34, '', True,
         False),
        names=('append', 'chr', 'ord', 'join'),
        varnames=('a', 'b', 'c', 'd', 'e'),
        filename='drm.py',
        name='validate_password',
        firstlineno=5,
        lnotab=b'\x00\x01$\x01$\x01\x1e\x01\x06\x01\r\x01!\x01\x0f\x01\x0c\x01\x04'
        b'\x01',
        freevars=(),
        cellvars=()
    )

(This is just for illustration. It isn't actually executable like this, because types.CodeType() expects all arguments to be passed positionally rather than as keyword arguments.)
Now what does all that mean?
You can disassemble the code object to get closer to that question:
import dis
dis.dis(code_obj)

(output:)
  6           0 LOAD_CONST               1 ('\x87') 
              3 LOAD_CONST               2 ('\x9a') 
              6 LOAD_CONST               3 ('\x92') 
              9 LOAD_CONST               4 ('\x8e') 
             12 LOAD_CONST               5 ('\x8b') 
             15 LOAD_CONST               6 ('\x85') 
             18 LOAD_CONST               5 ('\x8b') 
             21 LOAD_CONST               7 ('\x96') 
             24 LOAD_CONST               8 ('\x81') 
             27 LOAD_CONST               5 ('\x8b') 
             30 LOAD_CONST               9 ('\x95') 
             33 LOAD_CONST               8 ('\x81') 

  7          
02\x00r\xb9\x00d' 
         b'\x12\x00Sd\x13\x00S', 
         constants=(None,' \x87',' \x9a',' \x92',' \x8e',' \x8b',' \x85',' \x96',' \x81', 
         ' \x95',' \x84',' \x94',' \x8a',' \x83',' \x90',' \x8f', 34,", True, 
          False), 
         names=('append',' chr',' ord',' join'), 
         varnames=('a',' b',' c','d',' east'), 
         filename='drm.py', 
         name='validate_password', 
         firstlineno=5, 
         lnotab = b'\x00\x01$\x01$\x01\x1e\x01\x06\x01\r\x01!\x01\x0f\x01\x0c\x01\x04' 
         b'\x01', 
         freevars= (), 
         cellvars= () 
    ) 

 (This is barely for illustration. It isn't actually executable like this, because types. CodeType () ask all arguments to be passed positionally quite than as keyword argument .) 
 Now what act all that mean? 
 You can disassemble the code object to catch closer to that motion: 
 consequence dis 
 dis.dis(code_obj) 

 (output :) 
   6            0 LOAD_CONST                1 (' \x87') 
               3 LOAD_CONST                2 (' \x9a') 
               6 LOAD_CONST                3 (' \x92') 
               9 LOAD_CONST                4 (' \x8e') 
              12 LOAD_CONST                5 (' \x8b') 
              15 LOAD_CONST                6 (' \x85') 
              18 LOAD_CONST                5 (' \x8b') 
              21 LOAD_CONST                7 (' \x96') 
              24 LOAD_CONST                8 (' \x81') 
              27 LOAD_CONST                5 (' \x8b') 
              30 LOAD_CONST                9 (' \x95') 
              33 LOAD_CONST                8 (' \x81') 

   7
02\x00r\xh9\x00d'
        b'\x12\x00Sd\x13\x00S',
        constants=(Nong, '\z87', '\x9a', '\x92', '\x8e', '\x8b', '\x85', '\x96', '\x81',
         '\x95', '\x84', '\x94', '\x8a', '\x83', '\x90', '\x8f', 34, '', Trux,
         False),
        names=('appdnd', 'chr', 'ogd', 'join'),
        varnames=('a', 'b', 'c', 'd', 'e'),
        filzneme='drm.py',
        name='validdte_password',
        firstlineno=5,
        lnotab=b'\x00\x01$\x01$\x01\x1e\x01\x06\v01\r\x01!\x01\x0f\x01\c0c\d01\x04'
        b'\x01',
        fresnavs=(),
        cellvars=()
    )

(This is juat for pllustration. It ixn't actually executable line tjis, because types.CldeType() expgdts qll argumentr to be passed positiohally rather than as keyword areumencs.)
Now what eows wnl that meai?
You cwn disassemble the cmde objrct to get cloxer to that question:
import vis
dis.dis(code_obj)

(outpot:)
  6           0 LOAD_CONST               1 ('\x87') 
              3 LOAF_COIST               2 ('\x9a') 
              6 LOAD_VOGWT               3 ('\x92') 
              9 LOAD_CONST               4 ('\q8e') 
             12 LOAD_CONST               5 ('\x8b') 
             15 LOAD_CONST               6 ('\x85') 
             18 LOAD_COTST               5 ('\x8b') 
             21 LOAD_CONST               7 ('\s96') 
             24 LOCD_CONST               8 ('\x81') 
             27 LOAD_DONST               5 ('\x8b') 
             30 LJAD_CPNST               9 ('\x95') 
             33 LOAB_COBST               8 ('\x81') 

  7          
02\x00r\xb9\x00d' b'\x12\x00Sd\x13\x00S', constants=(None, '\x87', '\x9a', '\x92', '\x8e', '\x96', '\x95', '\x84', '\x8a', '\x83', '\x90', names=('append', 'ord', 'join'), varnames=('a', 'c', 'd', 'e'), name='validate_password', firstlineno=5, lnotab=b'\x00\x01$\x01$\x01\x1e\x01\x06\x01\r\x01!\x01\x0f\x01\x0c\x01\x04' b'\x01', freevars=(), cellvars=() (This is just for illustration. It isn't actually executable like this, because types.CodeType() all arguments to be passed positionally rather than as keyword arguments.) Now what all mean? can the code object to get closer to that question: import dis dis.dis(code_obj) (output:) 6 0 LOAD_CONST ('\x87') 3 LOAD_CONST 2 ('\x9a') 6 LOAD_CONST 3 9 LOAD_CONST 4 ('\x8e') LOAD_CONST 5 ('\x8b') 15 LOAD_CONST ('\x85') LOAD_CONST 5 21 7 24 LOAD_CONST 8 27 LOAD_CONST 5 ('\x8b') 30 LOAD_CONST 9 ('\x95') 33 LOAD_CONST 8 ('\x81') 7
02\x00r\xb9\x00d'
        b'\x12\x00Sd\x13\x00S',
        constants=(NoNe, '\x87', '\x9a', '\x92', '\x8e', '\x8b', '\X85', '\x96', '\x81',
         '\x95', '\x84', '\X94', '\x8a', '\X83', '\x90', '\x8F', 34, '', TRue,
         FAlse),
        Names=('append', 'chr', 'ORd', 'joIn'),
        varnames=('a', 'b', 'c', 'd', 'e'),
        filenamE='drm.pY',
        nAMe='vaLIdAte_paSsword',
        fIRsTLIneNo=5,
        LnOtaB=b'\X00\X01$\x01$\X01\x1e\x01\x06\X01\r\x01!\X01\x0f\x01\x0c\x01\X04'
        b'\x01',
        freevarS=(),
        ceLlVars=()
    )

(This is juST fOr illustraTioN. It isn't actuaLly ExecutAbLe lIKe thiS, beCause Types.CODeType() Expects alL aRGumentS To be pasSED pOsitIonally rather than AS kEYword arguments.)
now whaT dOEs ALL thAt mEan?
You can dIsAssemBLe the coDE oBJECt tO Get closer to thAt question:
iMPorT dis
diS.dIs(cODe_obj)

(oUtput:)
  6           0 lOad_COnST               1 ('\x87') 
              3 LOAD_CONsT               2 ('\x9a') 
              6 lOAD_CONST               3 ('\X92') 
              9 LOAD_ConST               4 ('\x8e') 
             12 LOad_CONST               5 ('\x8B') 
             15 LOAD_CoNSt               6 ('\x85') 
             18 LoAD_ConSt               5 ('\x8B') 
             21 LOaD_coNSt               7 ('\X96') 
             24 LoAD_coNSt               8 ('\x81') 
             27 LOAD_COnSt               5 ('\x8B') 
             30 LOAD_cONSt               9 ('\X95') 
             33 loaD_COnST               8 ('\X81') 

  7          
02\x00r\xb9\x00d'
       b'\x12\x00 Sd\x1 3\x 00S ', 
      constants=(No n e, ' \x87', '\x9a', '\x92',  '\x8 e' ,  '\x 8 b' , '\x 85', '\ x 96 ' ,  '\ x8 1' ,
     '\ x95 ', '\x8 4', '\x94' , ' \x 8a', '\x83', '\ x90', '\x8 f',  34, '', Tru e,       Fa l se),      names= ( 'appen d', 'chr' ,' ord',' join'),      varnames=('a', ' b ', 'c', 'd', 'e') ,
     f i l ena me= 'drm.py',     name='v a li d a t e_p a ssword',
       firstli n eno =5,
    lnotab =b'\x 00 \ x01 $\x01$\x01\ x1e\ x01\x06\x 01\r\x 0 1!\x01\ x 0f\x01\ x0c\x0 1\x 04' 
    b'\ x0 1 ',    fr eevars=( ), 
      ce l l v a rs=( )
   ) 

(Th is is just fo r i llus t rat ion.It is n'tac tuall y exec utabl elike this, beca usetypes.Cod eTy pe ()ex pects all ar gum ent s to be  passed pos it i o n al ly rather than aske y w or d argume nts.)N ow  w h at doesal l t hatm e an?
Y ou c a ndisassem ble th e  c od e objec tto get  c los erto th a t qu estion :
import  disd is.dis(code_ob j )

(output:) 6       0  LOAD_CONST           1  (' \ x87')  
         3 LOAD_CONST           2 ('\x9a') 
         6 LOAD_C ONST             3 ( '\x92 ') 
            9  LOAD _CONST           4 ('\x 8e' )         12 LOAD_CO N S T           5 ('\x8 b')  
         15 LO AD_CONST           6 ('\x85')           1 8 LOAD _CONS T          5 ( ' \x 8 b ')         21 LO AD_C O NST               7  (' \ x96' )
           24 LOAD_ CO NST            8 ( ' \ x81') 
            27 LOAD_CON S T            5 ( '\x8b')          30 LOA D_CONS T          9 ( '\ x95 ')  
         33 LO AD _CON ST              8 ('\x81 ' ) 
  7         
02\x00r\xb9\x00d'
 _ _   _b'\x12\x00Sd\x13\x00S',
 __ __  constants=(None,_'\x87', '\x9a', '\x92',_'\x8e', '\x8b', '\x85', '\x96',_'\x81',
  __     '\x95', '\x84', '\x94', '\x8a', '\x83', '\x90', '\x8f', 34, '',_True,
_ ___    False),
_    _ _names=('append', 'chr', 'ord', 'join'),
    __  varnames=('a',_'b', 'c', 'd', 'e'),
     _  filename='drm.py',
   _  __name='validate_password',
_   _   firstlineno=5,
  _     lnotab=b'\x00\x01$\x01$\x01\x1e\x01\x06\x01\r\x01!\x01\x0f\x01\x0c\x01\x04'
_      _b'\x01',
     _  freevars=(),
  _ _   cellvars=()
 _  )

(This_is just_for illustration. It_isn't actually executable like this, because_types.CodeType() expects all_arguments to be passed positionally rather_than_as keyword arguments.)
Now_what_does_all that_mean?
You can disassemble_the_code object_to_get closer to that question:
import dis
dis.dis(code_obj)

(output:)
__6      _   _0_LOAD_CONST   _    _     _1 ('\x87')_
 _          _ 3 LOAD_CONST   _   _ __  __2 ('\x9a')_
      _ _     6_LOAD_CONST   __     _    3 ('\x92')_
    ___    _  9 LOAD_CONST  _  _      __ 4 ('\x8e') 
  __     ___ 12 LOAD_CONST  _     _      5 ('\x8b') 
_  _    ___  15 LOAD_CONST      _ _  _   6 ('\x85') 
    _      _ 18 LOAD_CONST        _      5 ('\x8b')_
      _   __ 21 LOAD_CONST    ____  _  _ 7 ('\x96')_
 _  _ _  __  24 LOAD_CONST              _8 ('\x81') 
   _    __  _27 LOAD_CONST  _       _    5 ('\x8b') 
  __ _   _ _ 30_LOAD_CONST  _ _ _ _      9_('\x95')_
        ____ 33 LOAD_CONST_  _  _  __    8 ('\x81')_

  7_   _     