Python 2, 74 72 bytes

lambda s:':'.join(['AM','PM','00',`ord(c)-97`]['az '.find(c)]for c in s)

Try it online!

Takes input as all lowercase

05AB1E, 22 21 bytes

„AM24L„PM00)˜Að«s‡':ý

Try it online!
or as a Test Suite

Some alternate 21 byte solutions:

':ýAð«24L„AMš„PMª00ª‡

00„AM24L„PM)˜AIk>è':ý

Perl 6, 47 bytes

*.ords>>.&{<<00 AM{1..24}PM>>[$_%32]}.join(":")

Try it online!

Anonymous Whatever lambda that takes a string of either case and returns the encrypted string.

Explanation:

*.ords>>.&{                         } # Map the ordinal values to

           <<              >>[$_%32]  # The index in the list

              00 AM{1..24}PM  # 00, AM, the numbers 1 to 24 and PM

                                     .join(":")   # And join with colons

Pyth, 25 bytes

j:m@+++"AM"S24"PM""00"xG

Try it online here, or verify all the test cases at once here.

j:m@+++"AM"S24"PM""00"xGdQ   Implicit: Q=eval(input()), G=lowercase alphabet

                              Trailing dQ inferred

            S24               [1-24]

       +"AM"                  Prepend "AM"

      +        "PM"           Append "PM"

     +             "00"       Append "00" - this is the dictionary

   m                      Q   Map each element of Q, as d, using:

                       xGd      Get the index of d in G, -1 if not present (i.e. space)

    @                           Get the element from the dictionary at the above index

j:                           Join the result on ":", implicit print

JavaScript (Node.js), 72 bytes

Takes input in lowercase.

s=>[...s].map(c=>c<1?'00':(x=Buffer(c)[0]-1&31)>24?'PM':x||'AM').join`:`

Try it online!

C# (Visual C# Interactive Compiler), 72 bytes

s=>string.Join(":",s.Select(a=>a<33?"00":a<66?"AM":a>89?"PM":a%32-1+""))

Takes input as a string of lowercase letters. First checks if the char is a space, and if it is, converts it to 00. Next, it checks for if the char is an A, and converts it to AM. It checks again for Z and converts it to PM if it is. Lastly, if the char passes all the checks, it gets converted to its alphabetic order-1.

Try it online!

// Input taking a string

s => 

// Join the following IEnumerable<char> with a ":" character

string.Join(":", 

// Map all the characters in the string

s.Select(a => 

// Is the char less than 33, aka a space?

a < 33 ? 

// If so, it's a "00"

"00" 

// Else, is this an 'A'?

: a < 66 ?

// If so, convert it to "AM"

"AM" : 

// If it's not 'A' or a space, could it be a 'Z'?

a > 89 ?

// If it is, turn the character into "PM"

"PM" : 

// If it fails all of the checks above, get the characters position in the alphabet and subtract one from that.

a % 32 - 1 + ""))

Java (JDK), 95 bytes

s->{int a=0;for(var c:s)System.out.print((a++<1?"":":")+(c<33?"00":c<66?"AM":c>89?"PM":c-65));}

Try it online!

Credits

• -1 byte thanks to Kevin Cruijssen

Ruby, 49 bytes

->a{a.map{|c|["00",:AM,*1..24,:PM][c.ord%32]}*?:}

Try it online!

Port of Jo King's Perl answer.
Takes input as an array of chars, returns a string with AM/PM in uppercase.

Red, 124 121 110 109 bytes

func[s][replace/all form collect[forall s[keep switch/default

c: -97 + s/1[0['AM]25['PM]-65["00"]][c]]]sp":"]

Try it online!

Tcl, 100 bytes

proc C s {join [lmap c [split $s ""] {scan $c %c v

expr $v==65?"AM":$v==90?"PM":$v==32?00:$v-65}] :}

Try it online!

05AB1E, 20 bytes

':ýð00:A24L„AMš„PMª‡

Greatly inspired by @Mr.Xcoder's 22-byter in the comment of the existing 05AB1E answer by @Emigna.

Takes the input as a list of lowercase characters (would be 21 bytes with a leading S if I take the input as a string).

Try it online or verify all test cases.

Explanation:

':ý            '# Join the (implicit) input list of characters by ":"

                #  i.e. ["e","a","s","y"," ","p","e","a","z","y"] → "e:a:s:y: :p:e:a:z:y"

ð00:            # Replace all spaces " " with "00"

                #  i.e. "e:a:s:y: :p:e:a:z:y" → "e:a:s:y:00:p:e:a:z:y"

A               # Push the lowercase alphabet

 24L            # Push a list in the range [1,24]

    „AMš        # Prepend "AM" at the start of this list

        „PMª    # And append "PM" at the end of the list

            ‡   # Transliterate; mapping letters to the list-items at the same indices

                # (and output the result implicitly)

                #  i.e. "e:a:s:y:00:p:e:a:z:y" → "4:AM:18:24:00:15:4:AM:PM:24"

C# (Visual C# Interactive Compiler), 98 bytes

s=>string.Join(':',s.Select(c=>"az ".Contains(c)?new{"AM","PM","00"}["az ".IndexOf(c)]:c-97+""))

Takes input as a (lowercase) char array. Try it online!

Charcoal, 26 bytes

ＵＢ:Ｆθ«→≡ι ×0²a¦AM¦z¦PMＩ⌕βι

Try it online! Link is to verbose version of code. Takes input in lower case (can trivially be changed to upper case). Explanation:

ＵＢ:

Set the background character to :. This fills in the gaps between the output values created by the right movement.

Ｆθ«→

Loop over each character, leaving a gap each time. (The first move has no effect as the canvas is still empty at this point.)

≡ι ×0²a¦AM¦z¦PM

Switch on the character and if it's space, a or z then output the appropriate code. I use ×0² instead of 00 here as the latter would cost two bytes in additional separators.

Ｉ⌕βι

Otherwise output the letter's 0-indexed position in the lower case alphabet as a string.