pandas borrows its dtypes from numpy. For demonstration of this see the following:

import pandas as pd

df = pd.DataFrame({'A': [1,'C',2.]})
df['A'].dtype

>>> dtype('O')

type(df['A'].dtype)

>>> numpy.dtype

You can find the list of valid numpy.dtypes in the documentation:

'?' boolean

'b' (signed) byte

'B' unsigned byte

'i' (signed) integer

'u' unsigned integer

'f' floating-point

'c' complex-floating point

'm' timedelta

'M' datetime

'O' (Python) objects

'S', 'a' zero-terminated bytes (not recommended)

'U' Unicode string

'V' raw data (void)

pandas should support these types. Using the astype method of a pandas.Series object with any of the above options as the input argument will result in pandas trying to convert the Series to that type (or at the very least falling back to object type); 'u' is the only one that I see pandas not understanding at all:

df['A'].astype('u')

>>> TypeError: data type "u" not understood

This is a numpy error that results because the 'u' needs to be followed by a number specifying the number of bytes per item in (which needs to be valid):

import numpy as np

np.dtype('u')

>>> TypeError: data type "u" not understood

np.dtype('u1')

>>> dtype('uint8')

np.dtype('u2')

>>> dtype('uint16')

np.dtype('u4')

>>> dtype('uint32')

np.dtype('u8')

>>> dtype('uint64')

# testing another invalid argument
np.dtype('u3')

>>> TypeError: data type "u3" not understood

To summarise, the astype methods of pandas objects will try and do something sensible with any argument that is valid for numpy.dtype. Note that numpy.dtype('f') is the same as numpy.dtype('float32') and numpy.dtype('f8') is the same as numpy.dtype('float64') etc. Same goes for passing the arguments to pandas astype methods.

To locate the respective data type classes in NumPy, the Pandas docs recommends this:

def subdtypes(dtype):
    subs = dtype.__subclasses__()
    if not subs:
        return dtype
    return [dtype, [subdtypes(dt) for dt in subs]]

subdtypes(np.generic)

Output:

[numpy.generic,
 [[numpy.number,
   [[numpy.integer,
     [[numpy.signedinteger,
       [numpy.int8,
        numpy.int16,
        numpy.int32,
        numpy.int64,
        numpy.int64,
        numpy.timedelta64]],
      [numpy.unsignedinteger,
       [numpy.uint8,
        numpy.uint16,
        numpy.uint32,
        numpy.uint64,
        numpy.uint64]]]],
    [numpy.inexact,
     [[numpy.floating,
       [numpy.float16, numpy.float32, numpy.float64, numpy.float128]],
      [numpy.complexfloating,
       [numpy.complex64, numpy.complex128, numpy.complex256]]]]]],
  [numpy.flexible,
   [[numpy.character, [numpy.bytes_, numpy.str_]],
    [numpy.void, [numpy.record]]]],
  numpy.bool_,
  numpy.datetime64,
  numpy.object_]]

Pandas accepts these classes as valid types. For example, dtype={'A': np.float}.

NumPy docs contain more details and a chart:

df.dtypes is the canonical way to obtain data type identifiers. You can print for each dtype the associated underlying numpy dtype code with <dtype>.str. You can also get the kind (integer, float, ...) with <dtype>.kind:

import pandas as pd
from datetime import datetime

headers = ["string", "integer", "float", "boolean", "timestamp"]
data = [["a", 1, 1.0, True, datetime.now()]]

df = pd.DataFrame(data, columns=headers)

dts = df.dtypes
for index, value in dts.items():
    print("column %s dtype[class: %s; name: %s; code: %s; kind: %s]" % (index, type(value), value.name, value.str, value.kind))

yields:

column string dtype[class: <class 'numpy.dtype'>; name: object; code: |O; kind: O]
column integer dtype[class: <class 'numpy.dtype'>; name: int64; code: <i8; kind: i]
column float dtype[class: <class 'numpy.dtype'>; name: float64; code: <f8; kind: f]
column boolean dtype[class: <class 'numpy.dtype'>; name: bool; code: |b1; kind: b]
column timestamp dtype[class: <class 'numpy.dtype'>; name: datetime64[ns]; code: <M8[ns]; kind: M]

The issue is that some datatypes are defined specifically in pandas as you noted, but they are backed by numpy datatypes (they have numpy datatype codes). For example, numpy defines the datetime64[ns] that you can see above, but pandas defines a timezone-localized dtype on top of it. You can see it :

# localize with timezone
df['timestamp'] = pd.DatetimeIndex(df['timestamp']).tz_localize(tz='UTC')

# look at the dtype of timestamp: now a pandas dtype
index, value = 'timestamp', df.dtypes.timestamp
print("column %s dtype[class: %s; name: %s; code: %s; kind: %s]" % (index, type(value), value.name, value.str, value.kind))

yields

column timestamp dtype[class: <class 'pandas.core.dtypes.dtypes.DatetimeTZDtype'>; name: datetime64[ns, UTC]; code: |M8[ns]; kind: M]    

Now the dtype class is a custom pandas class (DatetimeTZDtype), while the underlying dtype code is a numpy one. The same would go if you use string datatypes, that are not in numpy by default.

So to sum-up, to reach your original goal, you should first look at the type(<dtype>) and if it is not a custom pandas one, then to look at the numpy <dtype>.kind (It is preferrable to <dtype>.str as numpy allows you to define many kind of integers (big/little endian, nb of bits, etc.)).

Finally as you found out, Dataframe.convert_dtypes() is a converter, and it has parameters to select which auto-conversion feature to turn on/off.