diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 8b5beb0ef6..13ea5efa73 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -876,6 +876,10 @@ struct handle_type_name {
     static constexpr auto name = const_name<T>();
 };
 template <>
+struct handle_type_name<object> {
+    static constexpr auto name = const_name("object");
+};
+template <>
 struct handle_type_name<bool_> {
     static constexpr auto name = const_name("bool");
 };
diff --git a/include/pybind11/stl_bind.h b/include/pybind11/stl_bind.h
index 4d0854f6a8..1eb81f38d2 100644
--- a/include/pybind11/stl_bind.h
+++ b/include/pybind11/stl_bind.h
@@ -15,6 +15,8 @@
 #include "operators.h"
 
 #include <algorithm>
+#include <complex>
+#include <functional>
 #include <sstream>
 #include <type_traits>
 
@@ -483,6 +485,137 @@ void vector_buffer(Class_ &cl) {
         cl, detail::any_of<std::is_same<Args, buffer_protocol>...>{});
 }
 
+// Issue #3986 and #4529: map C++ types to Python types with typing strings
+template <typename T, typename SFINAE = void>
+struct type_mapper {
+    using py_type = T;
+    static std::string py_name() { return detail::type_info_description(typeid(T)); }
+};
+
+template <>
+struct type_mapper<std::nullptr_t> {
+    using py_type = pybind11::none;
+    static std::string py_name() {
+        constexpr auto descr = const_name("None");
+        return descr.text;
+    }
+};
+
+template <>
+struct type_mapper<bool> {
+    using py_type = pybind11::bool_;
+    static std::string py_name() {
+        constexpr auto descr = const_name("bool");
+        return descr.text;
+    }
+};
+
+template <typename T>
+struct type_mapper<T, enable_if_t<std::is_arithmetic<T>::value && !is_std_char_type<T>::value>> {
+    using py_type
+        = conditional_t<std::is_floating_point<T>::value, pybind11::float_, pybind11::int_>;
+    static std::string py_name() {
+        constexpr auto descr = const_name<std::is_integral<T>::value>("int", "float");
+        return descr.text;
+    }
+};
+
+template <typename T>
+struct type_mapper<std::complex<T>> {
+    using py_type = std::complex<typename type_mapper<T>::py_type>;
+    static std::string py_name() {
+        constexpr auto descr = const_name("complex");
+        return descr.text;
+    }
+};
+
+template <typename T>
+struct type_mapper<T, enable_if_t<is_std_char_type<T>::value>> {
+    using py_type = pybind11::str;
+    static std::string py_name() {
+        constexpr auto descr = const_name(PYBIND11_STRING_NAME);
+        return descr.text;
+    }
+};
+
+template <typename T>
+struct type_mapper<T, enable_if_t<is_pyobject<T>::value>> {
+    using py_type = T;
+    static std::string py_name() {
+        constexpr auto descr = handle_type_name<T>::name;
+        return descr.text;
+    }
+};
+
+template <typename T>
+struct type_mapper<std::shared_ptr<T>> : public type_mapper<T> {};
+
+template <typename T, typename Deleter>
+struct type_mapper<std::unique_ptr<T, Deleter>> : public type_mapper<T> {};
+
+template <typename CharT, typename Traits, typename Allocator>
+struct type_mapper<std::basic_string<CharT, Traits, Allocator>,
+                   enable_if_t<is_std_char_type<CharT>::value>> {
+    using py_type = pybind11::str;
+    static std::string py_name() {
+        constexpr auto descr = const_name(PYBIND11_STRING_NAME);
+        return descr.text;
+    }
+};
+
+#ifdef PYBIND11_HAS_STRING_VIEW
+template <typename CharT, typename Traits>
+struct type_mapper<std::basic_string_view<CharT, Traits>,
+                   enable_if_t<is_std_char_type<CharT>::value>> {
+    using py_type = pybind11::str;
+    static std::string py_name() {
+        constexpr auto descr = const_name(PYBIND11_STRING_NAME);
+        return descr.text;
+    }
+};
+#endif
+
+template <typename T1, typename T2>
+struct type_mapper<std::pair<T1, T2>> {
+    using py_type
+        = std::tuple<typename type_mapper<T1>::py_type, typename type_mapper<T1>::py_type>;
+    static std::string py_name() {
+        return "tuple[" + type_mapper<T1>::py_name() + ", " + type_mapper<T2>::py_name() + "]";
+    }
+};
+
+template <typename... Ts>
+struct type_mapper<std::tuple<Ts...>> {
+    using py_type = std::tuple<typename type_mapper<Ts>::py_type...>;
+    static std::string py_name() {
+        std::vector<std::string> names = {type_mapper<Ts>::py_name()...};
+        std::ostringstream s;
+        s << "tuple[";
+        for (size_t i = 0; i < names.size(); ++i) {
+            s << (i != 0 ? ", " : "") << names[i];
+        }
+        s << "]";
+        return s.str();
+    }
+};
+
+template <typename Return, typename... Args>
+struct type_mapper<std::function<Return(Args...)>> {
+    using retval_type = conditional_t<std::is_same<Return, void>::value, std::nullptr_t, Return>;
+    using py_type = std::function<typename type_mapper<retval_type>::py_type(
+        typename type_mapper<Args>::py_type...)>;
+    static std::string py_name() {
+        std::vector<std::string> names = {type_mapper<Args>::py_name()...};
+        std::ostringstream s;
+        s << "Callable[[";
+        for (size_t i = 0; i < names.size(); ++i) {
+            s << (i != 0 ? ", " : "") << names[i];
+        }
+        s << "], " << type_mapper<retval_type>::py_name() << "]";
+        return s.str();
+    }
+};
+
 PYBIND11_NAMESPACE_END(detail)
 
 //
@@ -649,8 +782,7 @@ template <typename KeyType>
 struct keys_view {
     virtual size_t len() = 0;
     virtual iterator iter() = 0;
-    virtual bool contains(const KeyType &k) = 0;
-    virtual bool contains(const object &k) = 0;
+    virtual bool contains(const handle &k) = 0;
     virtual ~keys_view() = default;
 };
 
@@ -673,8 +805,13 @@ struct KeysViewImpl : public KeysView {
     explicit KeysViewImpl(Map &map) : map(map) {}
     size_t len() override { return map.size(); }
     iterator iter() override { return make_key_iterator(map.begin(), map.end()); }
-    bool contains(const typename Map::key_type &k) override { return map.find(k) != map.end(); }
-    bool contains(const object &) override { return false; }
+    bool contains(const handle &k) override {
+        try {
+            return map.find(k.template cast<typename Map::key_type>()) != map.end();
+        } catch (const cast_error &) {
+            return false;
+        }
+    }
     Map &map;
 };
 
@@ -702,9 +839,11 @@ class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args &&
     using MappedType = typename Map::mapped_type;
     using StrippedKeyType = detail::remove_cvref_t<KeyType>;
     using StrippedMappedType = detail::remove_cvref_t<MappedType>;
-    using KeysView = detail::keys_view<StrippedKeyType>;
-    using ValuesView = detail::values_view<StrippedMappedType>;
-    using ItemsView = detail::items_view<StrippedKeyType, StrippedMappedType>;
+    using PyKeyType = typename detail::type_mapper<StrippedKeyType>::py_type;
+    using PyMappedType = typename detail::type_mapper<StrippedMappedType>::py_type;
+    using KeysView = detail::keys_view<PyKeyType>;
+    using ValuesView = detail::values_view<PyMappedType>;
+    using ItemsView = detail::items_view<PyKeyType, PyMappedType>;
     using Class_ = class_<Map, holder_type>;
 
     // If either type is a non-module-local bound type then make the map binding non-local as well;
@@ -718,20 +857,10 @@ class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args &&
     }
 
     Class_ cl(scope, name.c_str(), pybind11::module_local(local), std::forward<Args>(args)...);
-    static constexpr auto key_type_descr = detail::make_caster<KeyType>::name;
-    static constexpr auto mapped_type_descr = detail::make_caster<MappedType>::name;
-    std::string key_type_name(key_type_descr.text), mapped_type_name(mapped_type_descr.text);
-
-    // If key type isn't properly wrapped, fall back to C++ names
-    if (key_type_name == "%") {
-        key_type_name = detail::type_info_description(typeid(KeyType));
-    }
-    // Similarly for value type:
-    if (mapped_type_name == "%") {
-        mapped_type_name = detail::type_info_description(typeid(MappedType));
-    }
+    std::string key_type_name = detail::type_mapper<StrippedKeyType>::py_name();
+    std::string mapped_type_name = detail::type_mapper<StrippedMappedType>::py_name();
 
-    // Wrap KeysView[KeyType] if it wasn't already wrapped
+    // Wrap KeysView[PyKeyType] if it wasn't already wrapped
     if (!detail::get_type_info(typeid(KeysView))) {
         class_<KeysView> keys_view(
             scope, ("KeysView[" + key_type_name + "]").c_str(), pybind11::module_local(local));
@@ -741,10 +870,7 @@ class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args &&
                       keep_alive<0, 1>() /* Essential: keep view alive while iterator exists */
         );
         keys_view.def("__contains__",
-                      static_cast<bool (KeysView::*)(const KeyType &)>(&KeysView::contains));
-        // Fallback for when the object is not of the key type
-        keys_view.def("__contains__",
-                      static_cast<bool (KeysView::*)(const object &)>(&KeysView::contains));
+                      static_cast<bool (KeysView::*)(const handle &)>(&KeysView::contains));
     }
     // Similarly for ValuesView:
     if (!detail::get_type_info(typeid(ValuesView))) {
diff --git a/tests/test_stl_binders.cpp b/tests/test_stl_binders.cpp
index e52a03b6d2..32802eec50 100644
--- a/tests/test_stl_binders.cpp
+++ b/tests/test_stl_binders.cpp
@@ -187,6 +187,35 @@ TEST_SUBMODULE(stl_binders, m) {
     py::bind_map<std::map<std::string, double>>(m, "MapStringDouble");
     py::bind_map<std::unordered_map<std::string, double>>(m, "UnorderedMapStringDouble");
 
+    // test_map_view_types
+    py::bind_map<std::map<std::string, float>>(m, "MapStringFloat");
+    py::bind_map<std::unordered_map<std::string, float>>(m, "UnorderedMapStringFloat");
+    py::bind_map<std::map<int16_t, double>>(m, "MapInt16Double");
+    py::bind_map<std::map<int32_t, double>>(m, "MapInt32Double");
+    py::bind_map<std::map<int64_t, double>>(m, "MapInt64Double");
+    py::bind_map<std::map<uint64_t, double>>(m, "MapUInt64Double");
+    py::bind_map<std::map<std::pair<short, short>, double>>(m, "MapPairShortShortDouble");
+    py::bind_map<std::map<std::pair<short, long>, std::complex<float>>>(
+        m, "MapPairShortLongComplexFloat");
+    py::bind_map<std::map<std::pair<long, short>, std::complex<double>>>(
+        m, "MapPairLongShortComplexDouble");
+    py::bind_map<std::map<std::tuple<long, long>, std::complex<double>>>(
+        m, "MapTupleLongLongComplexDouble");
+    py::bind_map<std::map<char, std::function<float(int, float)>>>(m,
+                                                                   "MapCharFunctionFloatIntFloat");
+    py::bind_map<std::map<std::string, std::function<double(long, double)>>>(
+        m, "MapStringFunctionDoubleLongDouble");
+    py::bind_map<std::map<std::string, std::function<void(long, double)>>>(
+        m, "MapStringFunctionVoidLongDouble");
+    py::bind_map<std::map<std::string, std::nullptr_t>>(m, "MapStringNone");
+
+    py::bind_map<std::map<int, std::pair<std::map<int, int>, int>>>(m, "MapIntMapIntIntInt");
+    py::bind_map<std::map<int, std::pair<std::map<int, int>, long>>>(m, "MapIntMapIntIntLong");
+    py::bind_map<std::map<int, std::pair<std::map<long, int>, long>>>(m, "MapIntMapLongIntLong");
+
+    py::bind_map<std::map<pybind11::int_, int>>(m, "MapPyIntInt");
+    py::bind_map<std::map<pybind11::int_, pybind11::int_>>(m, "MapPyIntPyInt");
+
     // test_map_string_double_const
     py::bind_map<std::map<std::string, double const>>(m, "MapStringDoubleConst");
     py::bind_map<std::unordered_map<std::string, double const>>(m,
diff --git a/tests/test_stl_binders.py b/tests/test_stl_binders.py
index c00d45b926..4bbf2d0850 100644
--- a/tests/test_stl_binders.py
+++ b/tests/test_stl_binders.py
@@ -314,6 +314,8 @@ def test_map_delitem():
 def test_map_view_types():
     map_string_double = m.MapStringDouble()
     unordered_map_string_double = m.UnorderedMapStringDouble()
+    map_string_float = m.MapStringFloat()
+    unordered_map_string_float = m.UnorderedMapStringFloat()
     map_string_double_const = m.MapStringDoubleConst()
     unordered_map_string_double_const = m.UnorderedMapStringDoubleConst()
 
@@ -321,20 +323,123 @@ def test_map_view_types():
     assert map_string_double.values().__class__.__name__ == "ValuesView[float]"
     assert map_string_double.items().__class__.__name__ == "ItemsView[str, float]"
 
-    keys_type = type(map_string_double.keys())
-    assert type(unordered_map_string_double.keys()) is keys_type
-    assert type(map_string_double_const.keys()) is keys_type
-    assert type(unordered_map_string_double_const.keys()) is keys_type
+    assert map_string_float.keys().__class__.__name__ == "KeysView[str]"
+    assert map_string_float.values().__class__.__name__ == "ValuesView[float]"
+    assert map_string_float.items().__class__.__name__ == "ItemsView[str, float]"
+
+    keys_type = map_string_double.keys().__class__
+    assert unordered_map_string_double.keys().__class__ is keys_type
+    assert map_string_double_const.keys().__class__ is keys_type
+    assert unordered_map_string_double_const.keys().__class__ is keys_type
+    assert map_string_float.keys().__class__ is keys_type
+    assert unordered_map_string_float.keys().__class__ is keys_type
+
+    values_type = map_string_double.values().__class__
+    assert unordered_map_string_double.values().__class__ is values_type
+    assert map_string_double_const.values().__class__ is values_type
+    assert unordered_map_string_double_const.values().__class__ is values_type
+    assert map_string_float.values().__class__ is values_type
+    assert unordered_map_string_float.values().__class__ is values_type
+
+    items_type = map_string_double.items().__class__
+    assert unordered_map_string_double.items().__class__ is items_type
+    assert map_string_double_const.items().__class__ is items_type
+    assert unordered_map_string_double_const.items().__class__ is items_type
+    assert map_string_float.items().__class__ is items_type
+    assert unordered_map_string_float.items().__class__ is items_type
+
+    map_int16_double = m.MapInt16Double()
+    map_int32_double = m.MapInt32Double()
+    map_int64_double = m.MapInt64Double()
+    map_uint64_double = m.MapUInt64Double()
+
+    assert map_int16_double.keys().__class__.__name__ == "KeysView[int]"
+    assert map_int16_double.keys().__class__ is map_int32_double.keys().__class__
+    assert map_int16_double.keys().__class__ is map_int64_double.keys().__class__
+    assert map_int16_double.keys().__class__ is map_uint64_double.keys().__class__
+
+    assert (1 << 50) not in map_uint64_double.keys()
+    map_uint64_double[1 << 50] = 1.0
+    assert (1 << 50) in map_uint64_double.keys()
+
+    map_pair_short_short_double = m.MapPairShortShortDouble()
+    map_pair_short_long_complex_float = m.MapPairShortLongComplexFloat()
+    map_pair_long_short_complex_double = m.MapPairLongShortComplexDouble()
+    map_tuple_long_long_complex_double = m.MapTupleLongLongComplexDouble()
+    assert (
+        map_pair_short_long_complex_float.keys().__class__.__name__
+        == "KeysView[tuple[int, int]]"
+    )
+    assert (
+        map_pair_short_long_complex_float.values().__class__.__name__
+        == "ValuesView[complex]"
+    )
+    assert (
+        map_pair_short_long_complex_float.items().__class__.__name__
+        == "ItemsView[tuple[int, int], complex]"
+    )
+    assert (
+        map_pair_short_long_complex_float.keys().__class__
+        is map_pair_short_short_double.keys().__class__
+    )
+    assert (
+        map_pair_short_long_complex_float.keys().__class__
+        is map_pair_long_short_complex_double.keys().__class__
+    )
+    assert (
+        map_pair_short_long_complex_float.keys().__class__
+        is map_tuple_long_long_complex_double.keys().__class__
+    )
+    assert (
+        map_pair_short_long_complex_float.values().__class__
+        is map_pair_long_short_complex_double.values().__class__
+    )
+    assert (
+        map_pair_short_long_complex_float.values().__class__
+        is map_tuple_long_long_complex_double.values().__class__
+    )
 
-    values_type = type(map_string_double.values())
-    assert type(unordered_map_string_double.values()) is values_type
-    assert type(map_string_double_const.values()) is values_type
-    assert type(unordered_map_string_double_const.values()) is values_type
+    map_char_func_fif = m.MapCharFunctionFloatIntFloat()
+    map_string_func_dld = m.MapStringFunctionDoubleLongDouble()
+    assert map_char_func_fif.keys().__class__.__name__ == "KeysView[str]"
+    assert (
+        map_char_func_fif.values().__class__.__name__
+        == "ValuesView[Callable[[int, float], float]]"
+    )
+    assert (
+        map_char_func_fif.items().__class__.__name__
+        == "ItemsView[str, Callable[[int, float], float]]"
+    )
+    assert map_char_func_fif.keys().__class__ is map_string_func_dld.keys().__class__
+    assert (
+        map_char_func_fif.values().__class__ is map_string_func_dld.values().__class__
+    )
+    assert map_char_func_fif.items().__class__ is map_string_func_dld.items().__class__
+
+    map_string_func_vld = m.MapStringFunctionVoidLongDouble()
+    map_string_none = m.MapStringNone()
+    assert (
+        map_string_func_vld.values().__class__.__name__
+        == "ValuesView[Callable[[int, float], None]]"
+    )
+    assert map_string_none.values().__class__.__name__ == "ValuesView[None]"
+
+    map_int_map_int_int_int = m.MapIntMapIntIntInt()
+    map_int_map_int_int_long = m.MapIntMapIntIntLong()
+    map_int_map_long_int_long = m.MapIntMapLongIntLong()
+    assert (
+        map_int_map_int_int_int.values().__class__
+        is map_int_map_int_int_long.values().__class__
+    )
+    assert (
+        map_int_map_int_int_long.values().__class__
+        is not map_int_map_long_int_long.values().__class__
+    )
 
-    items_type = type(map_string_double.items())
-    assert type(unordered_map_string_double.items()) is items_type
-    assert type(map_string_double_const.items()) is items_type
-    assert type(unordered_map_string_double_const.items()) is items_type
+    map_pyint_int = m.MapPyIntInt()
+    map_pyint_pyint = m.MapPyIntPyInt()
+    assert map_pyint_int.items().__class__.__name__ == "ItemsView[int, int]"
+    assert map_pyint_int.items().__class__ is map_pyint_pyint.items().__class__
 
 
 def test_recursive_vector():