diff --git a/asv_bench/benchmarks/tslibs/timestamp.py b/asv_bench/benchmarks/tslibs/timestamp.py
index 082220ee0dff2..6145966fb6a0e 100644
--- a/asv_bench/benchmarks/tslibs/timestamp.py
+++ b/asv_bench/benchmarks/tslibs/timestamp.py
@@ -1,7 +1,10 @@
-from datetime import datetime
+from datetime import (
+    datetime,
+    timezone,
+)
+import zoneinfo
 
 import numpy as np
-import pytz
 
 from pandas import Timestamp
 
@@ -12,7 +15,7 @@ class TimestampConstruction:
     def setup(self):
         self.npdatetime64 = np.datetime64("2020-01-01 00:00:00")
         self.dttime_unaware = datetime(2020, 1, 1, 0, 0, 0)
-        self.dttime_aware = datetime(2020, 1, 1, 0, 0, 0, 0, pytz.UTC)
+        self.dttime_aware = datetime(2020, 1, 1, 0, 0, 0, 0, timezone.utc)
         self.ts = Timestamp("2020-01-01 00:00:00")
 
     def time_parse_iso8601_no_tz(self):
@@ -113,7 +116,7 @@ def setup(self, tz):
         self.ts = Timestamp("2017-08-25 08:16:14", tz=tz)
 
     def time_replace_tz(self, tz):
-        self.ts.replace(tzinfo=pytz.timezone("US/Eastern"))
+        self.ts.replace(tzinfo=zoneinfo.ZoneInfo("US/Eastern"))
 
     def time_replace_None(self, tz):
         self.ts.replace(tzinfo=None)
@@ -144,8 +147,8 @@ def time_ceil(self, tz):
 
 class TimestampAcrossDst:
     def setup(self):
-        dt = datetime(2016, 3, 27, 1)
-        self.tzinfo = pytz.timezone("CET").localize(dt, is_dst=False).tzinfo
+        dt = datetime(2016, 3, 27, 1, fold=0)
+        self.tzinfo = dt.astimezone(zoneinfo.ZoneInfo("Europe/Berlin")).tzinfo
         self.ts2 = Timestamp(dt)
 
     def time_replace_across_dst(self):
diff --git a/asv_bench/benchmarks/tslibs/tslib.py b/asv_bench/benchmarks/tslibs/tslib.py
index 4a011d4bb3f06..885cf48d01743 100644
--- a/asv_bench/benchmarks/tslibs/tslib.py
+++ b/asv_bench/benchmarks/tslibs/tslib.py
@@ -20,13 +20,13 @@
     timedelta,
     timezone,
 )
+import zoneinfo
 
 from dateutil.tz import (
     gettz,
     tzlocal,
 )
 import numpy as np
-import pytz
 
 try:
     from pandas._libs.tslibs import ints_to_pydatetime
@@ -38,7 +38,7 @@
     None,
     timezone.utc,
     timezone(timedelta(minutes=60)),
-    pytz.timezone("US/Pacific"),
+    zoneinfo.ZoneInfo("US/Pacific"),
     gettz("Asia/Tokyo"),
     tzlocal_obj,
 ]
diff --git a/asv_bench/benchmarks/tslibs/tz_convert.py b/asv_bench/benchmarks/tslibs/tz_convert.py
index c6b510efdca69..c87adb5e5d0e9 100644
--- a/asv_bench/benchmarks/tslibs/tz_convert.py
+++ b/asv_bench/benchmarks/tslibs/tz_convert.py
@@ -1,5 +1,6 @@
+from datetime import timezone
+
 import numpy as np
-from pytz import UTC
 
 from pandas._libs.tslibs.tzconversion import tz_localize_to_utc
 
@@ -41,7 +42,7 @@ def time_tz_convert_from_utc(self, size, tz):
         #  dti = DatetimeIndex(self.i8data, tz=tz)
         #  dti.tz_localize(None)
         if old_sig:
-            tz_convert_from_utc(self.i8data, UTC, tz)
+            tz_convert_from_utc(self.i8data, timezone.utc, tz)
         else:
             tz_convert_from_utc(self.i8data, tz)
 
diff --git a/doc/source/user_guide/io.rst b/doc/source/user_guide/io.rst
index dc06dd9620c24..667459c786f48 100644
--- a/doc/source/user_guide/io.rst
+++ b/doc/source/user_guide/io.rst
@@ -4990,7 +4990,7 @@ Caveats
   convenience you can use ``store.flush(fsync=True)`` to do this for you.
 * Once a ``table`` is created columns (DataFrame)
   are fixed; only exactly the same columns can be appended
-* Be aware that timezones (e.g., ``pytz.timezone('US/Eastern')``)
+* Be aware that timezones (e.g., ``zoneinfo.ZoneInfo('US/Eastern')``)
   are not necessarily equal across timezone versions.  So if data is
   localized to a specific timezone in the HDFStore using one version
   of a timezone library and that data is updated with another version, the data
@@ -5169,6 +5169,8 @@ See the `Full Documentation <https://github.com/wesm/feather>`__.
 
 .. ipython:: python
 
+   import pytz
+
    df = pd.DataFrame(
        {
            "a": list("abc"),
@@ -5178,7 +5180,7 @@ See the `Full Documentation <https://github.com/wesm/feather>`__.
            "e": [True, False, True],
            "f": pd.Categorical(list("abc")),
            "g": pd.date_range("20130101", periods=3),
-           "h": pd.date_range("20130101", periods=3, tz="US/Eastern"),
+           "h": pd.date_range("20130101", periods=3, tz=pytz.timezone("US/Eastern")),
            "i": pd.date_range("20130101", periods=3, freq="ns"),
        }
    )
diff --git a/doc/source/user_guide/timeseries.rst b/doc/source/user_guide/timeseries.rst
index d5137baa95ab8..9e5b786bce9aa 100644
--- a/doc/source/user_guide/timeseries.rst
+++ b/doc/source/user_guide/timeseries.rst
@@ -2337,7 +2337,7 @@ Time zone handling
 ------------------
 
 pandas provides rich support for working with timestamps in different time
-zones using the ``pytz`` and ``dateutil`` libraries or :class:`datetime.timezone`
+zones using the ``zoneinfo``, ``pytz`` and ``dateutil`` libraries or :class:`datetime.timezone`
 objects from the standard library.
 
 
@@ -2354,14 +2354,14 @@ By default, pandas objects are time zone unaware:
 To localize these dates to a time zone (assign a particular time zone to a naive date),
 you can use the ``tz_localize`` method or the ``tz`` keyword argument in
 :func:`date_range`, :class:`Timestamp`, or :class:`DatetimeIndex`.
-You can either pass ``pytz`` or ``dateutil`` time zone objects or Olson time zone database strings.
+You can either pass ``zoneinfo``, ``pytz`` or ``dateutil`` time zone objects or Olson time zone database strings.
 Olson time zone strings will return ``pytz`` time zone objects by default.
 To return ``dateutil`` time zone objects, append ``dateutil/`` before the string.
 
-* In ``pytz`` you can find a list of common (and less common) time zones using
-  ``from pytz import common_timezones, all_timezones``.
+* For ``zoneinfo``, a list of available timezones are available from :py:func:`zoneinfo.available_timezones`.
+* In ``pytz`` you can find a list of common (and less common) time zones using ``pytz.all_timezones``.
 * ``dateutil`` uses the OS time zones so there isn't a fixed list available. For
-  common zones, the names are the same as ``pytz``.
+  common zones, the names are the same as ``pytz`` and ``zoneinfo``.
 
 .. ipython:: python
 
@@ -2466,7 +2466,7 @@ you can use the ``tz_convert`` method.
 
 .. warning::
 
-    If you are using dates beyond 2038-01-18, due to current deficiencies
+    If you are using dates beyond 2038-01-18 with ``pytz``, due to current deficiencies
     in the underlying libraries caused by the year 2038 problem, daylight saving time (DST) adjustments
     to timezone aware dates will not be applied. If and when the underlying libraries are fixed,
     the DST transitions will be applied.
@@ -2475,9 +2475,11 @@ you can use the ``tz_convert`` method.
 
     .. ipython:: python
 
+      import pytz
+
        d_2037 = "2037-03-31T010101"
        d_2038 = "2038-03-31T010101"
-       DST = "Europe/London"
+       DST = pytz.timezone("Europe/London")
        assert pd.Timestamp(d_2037, tz=DST) != pd.Timestamp(d_2037, tz="GMT")
        assert pd.Timestamp(d_2038, tz=DST) == pd.Timestamp(d_2038, tz="GMT")
 
diff --git a/pandas/_libs/tslibs/nattype.pyx b/pandas/_libs/tslibs/nattype.pyx
index c483814a3ef74..c86de47eaacb9 100644
--- a/pandas/_libs/tslibs/nattype.pyx
+++ b/pandas/_libs/tslibs/nattype.pyx
@@ -841,7 +841,7 @@ class NaTType(_NaT):
 
         Parameters
         ----------
-        tz : str, pytz.timezone, dateutil.tz.tzfile or None
+        tz : str, zoneinfo.ZoneInfo, pytz.timezone, dateutil.tz.tzfile or None
             Time zone for time which Timestamp will be converted to.
             None will remove timezone holding UTC time.
 
@@ -894,7 +894,7 @@ class NaTType(_NaT):
         ----------
         ordinal : int
             Date corresponding to a proleptic Gregorian ordinal.
-        tz : str, pytz.timezone, dateutil.tz.tzfile or None
+        tz : str, zoneinfo.ZoneInfo, pytz.timezone, dateutil.tz.tzfile or None
             Time zone for the Timestamp.
 
         Notes
@@ -1301,7 +1301,7 @@ timedelta}, default 'raise'
 
         Parameters
         ----------
-        tz : str, pytz.timezone, dateutil.tz.tzfile or None
+        tz : str, zoneinfo.ZoneInfo, pytz.timezone, dateutil.tz.tzfile or None
             Time zone for time which Timestamp will be converted to.
             None will remove timezone holding UTC time.
 
@@ -1355,7 +1355,7 @@ timedelta}, default 'raise'
 
         Parameters
         ----------
-        tz : str, pytz.timezone, dateutil.tz.tzfile or None
+        tz : str, zoneinfo.ZoneInfo, pytz.timezone, dateutil.tz.tzfile or None
             Time zone for time which Timestamp will be converted to.
             None will remove timezone holding local time.
 
@@ -1455,13 +1455,13 @@ default 'raise'
 
         Replace timezone (not a conversion):
 
-        >>> import pytz
-        >>> ts.replace(tzinfo=pytz.timezone('US/Pacific'))
+        >>> import zoneinfo
+        >>> ts.replace(tzinfo=zoneinfo.ZoneInfo('US/Pacific'))
         Timestamp('2020-03-14 15:32:52.192548651-0700', tz='US/Pacific')
 
         Analogous for ``pd.NaT``:
 
-        >>> pd.NaT.replace(tzinfo=pytz.timezone('US/Pacific'))
+        >>> pd.NaT.replace(tzinfo=zoneinfo.ZoneInfo('US/Pacific'))
         NaT
         """,
     )
diff --git a/pandas/_libs/tslibs/timestamps.pyx b/pandas/_libs/tslibs/timestamps.pyx
index 04bd439b40b8d..ee958b5f65d1f 100644
--- a/pandas/_libs/tslibs/timestamps.pyx
+++ b/pandas/_libs/tslibs/timestamps.pyx
@@ -1374,7 +1374,7 @@ class Timestamp(_Timestamp):
         Timezone info.
     nanosecond : int, optional, default 0
         Value of nanosecond.
-    tz : str, pytz.timezone, dateutil.tz.tzfile or None
+    tz : str, zoneinfo.ZoneInfo, pytz.timezone, dateutil.tz.tzfile or None
         Time zone for time which Timestamp will have.
     unit : str
         Unit used for conversion if ts_input is of type int or float. The
@@ -1441,7 +1441,7 @@ class Timestamp(_Timestamp):
         ----------
         ordinal : int
             Date corresponding to a proleptic Gregorian ordinal.
-        tz : str, pytz.timezone, dateutil.tz.tzfile or None
+        tz : str, zoneinfo.ZoneInfo, pytz.timezone, dateutil.tz.tzfile or None
             Time zone for the Timestamp.
 
         Notes
@@ -2382,7 +2382,7 @@ timedelta}, default 'raise'
 
         Parameters
         ----------
-        tz : str, pytz.timezone, dateutil.tz.tzfile or None
+        tz : str, zoneinfo.ZoneInfo, pytz.timezone, dateutil.tz.tzfile or None
             Time zone for time which Timestamp will be converted to.
             None will remove timezone holding local time.
 
@@ -2489,7 +2489,7 @@ default 'raise'
 
         Parameters
         ----------
-        tz : str, pytz.timezone, dateutil.tz.tzfile or None
+        tz : str, zoneinfo.ZoneInfo, pytz.timezone, dateutil.tz.tzfile or None
             Time zone for time which Timestamp will be converted to.
             None will remove timezone holding UTC time.
 
@@ -2593,13 +2593,13 @@ default 'raise'
 
         Replace timezone (not a conversion):
 
-        >>> import pytz
-        >>> ts.replace(tzinfo=pytz.timezone('US/Pacific'))
+        >>> import zoneinfo
+        >>> ts.replace(tzinfo=zoneinfo.ZoneInfo('US/Pacific'))
         Timestamp('2020-03-14 15:32:52.192548651-0700', tz='US/Pacific')
 
         Analogous for ``pd.NaT``:
 
-        >>> pd.NaT.replace(tzinfo=pytz.timezone('US/Pacific'))
+        >>> pd.NaT.replace(tzinfo=zoneinfo.ZoneInfo('US/Pacific'))
         NaT
         """
 
diff --git a/pandas/_libs/tslibs/timezones.pyx b/pandas/_libs/tslibs/timezones.pyx
index 10e5790dd1c35..6292b6ce0fd1d 100644
--- a/pandas/_libs/tslibs/timezones.pyx
+++ b/pandas/_libs/tslibs/timezones.pyx
@@ -119,27 +119,26 @@ cpdef inline object get_timezone(tzinfo tz):
         raise TypeError("tz argument cannot be None")
     if is_utc(tz):
         return tz
+    elif is_zoneinfo(tz):
+        return tz.key
+    elif treat_tz_as_pytz(tz):
+        zone = tz.zone
+        if zone is None:
+            return tz
+        return zone
+    elif treat_tz_as_dateutil(tz):
+        if ".tar.gz" in tz._filename:
+            raise ValueError(
+                "Bad tz filename. Dateutil on python 3 on windows has a "
+                "bug which causes tzfile._filename to be the same for all "
+                "timezone files. Please construct dateutil timezones "
+                'implicitly by passing a string like "dateutil/Europe'
+                '/London" when you construct your pandas objects instead '
+                "of passing a timezone object. See "
+                "https://github.com/pandas-dev/pandas/pull/7362")
+        return "dateutil/" + tz._filename
     else:
-        if treat_tz_as_dateutil(tz):
-            if ".tar.gz" in tz._filename:
-                raise ValueError(
-                    "Bad tz filename. Dateutil on python 3 on windows has a "
-                    "bug which causes tzfile._filename to be the same for all "
-                    "timezone files. Please construct dateutil timezones "
-                    'implicitly by passing a string like "dateutil/Europe'
-                    '/London" when you construct your pandas objects instead '
-                    "of passing a timezone object. See "
-                    "https://github.com/pandas-dev/pandas/pull/7362")
-            return "dateutil/" + tz._filename
-        else:
-            # tz is a pytz timezone or unknown.
-            try:
-                zone = tz.zone
-                if zone is None:
-                    return tz
-                return zone
-            except AttributeError:
-                return tz
+        return tz
 
 
 cpdef inline tzinfo maybe_get_tz(object tz):
diff --git a/pandas/_testing/_hypothesis.py b/pandas/_testing/_hypothesis.py
index b7fc175b10d17..bbad21d8ab8d1 100644
--- a/pandas/_testing/_hypothesis.py
+++ b/pandas/_testing/_hypothesis.py
@@ -6,7 +6,6 @@
 
 from hypothesis import strategies as st
 from hypothesis.extra.dateutil import timezones as dateutil_timezones
-from hypothesis.extra.pytz import timezones as pytz_timezones
 
 from pandas.compat import is_platform_windows
 
@@ -57,7 +56,7 @@
 DATETIME_JAN_1_1900_OPTIONAL_TZ = st.datetimes(
     min_value=pd.Timestamp(1900, 1, 1).to_pydatetime(),  # pyright: ignore[reportArgumentType]
     max_value=pd.Timestamp(1900, 1, 1).to_pydatetime(),  # pyright: ignore[reportArgumentType]
-    timezones=st.one_of(st.none(), dateutil_timezones(), pytz_timezones()),
+    timezones=st.one_of(st.none(), dateutil_timezones(), st.timezones()),
 )
 
 DATETIME_IN_PD_TIMESTAMP_RANGE_NO_TZ = st.datetimes(
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index e0a4587535cfd..34d25f04b69e1 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -594,7 +594,7 @@ def tz(self) -> tzinfo | None:
 
         Returns
         -------
-        datetime.tzinfo, pytz.tzinfo.BaseTZInfo, dateutil.tz.tz.tzfile, or None
+        zoneinfo.ZoneInfo,, datetime.tzinfo, pytz.tzinfo.BaseTZInfo, dateutil.tz.tz.tzfile, or None
             Returns None when the array is tz-naive.
 
         See Also
@@ -624,7 +624,7 @@ def tz(self) -> tzinfo | None:
         ... )
         >>> idx.tz
         datetime.timezone.utc
-        """
+        """  # noqa: E501
         # GH 18595
         return getattr(self.dtype, "tz", None)
 
@@ -863,7 +863,7 @@ def tz_convert(self, tz) -> Self:
 
         Parameters
         ----------
-        tz : str, pytz.timezone, dateutil.tz.tzfile, datetime.tzinfo or None
+        tz : str, zoneinfo.ZoneInfo, pytz.timezone, dateutil.tz.tzfile, datetime.tzinfo or None
             Time zone for time. Corresponding timestamps would be converted
             to this time zone of the Datetime Array/Index. A `tz` of None will
             convert to UTC and remove the timezone information.
@@ -923,7 +923,7 @@ def tz_convert(self, tz) -> Self:
                        '2014-08-01 08:00:00',
                        '2014-08-01 09:00:00'],
                         dtype='datetime64[ns]', freq='h')
-        """
+        """  # noqa: E501
         tz = timezones.maybe_get_tz(tz)
 
         if self.tz is None:
@@ -955,7 +955,7 @@ def tz_localize(
 
         Parameters
         ----------
-        tz : str, pytz.timezone, dateutil.tz.tzfile, datetime.tzinfo or None
+        tz : str, zoneinfo.ZoneInfo,, pytz.timezone, dateutil.tz.tzfile, datetime.tzinfo or None
             Time zone to convert timestamps to. Passing ``None`` will
             remove the time zone information preserving local time.
         ambiguous : 'infer', 'NaT', bool array, default 'raise'
@@ -1081,7 +1081,7 @@ def tz_localize(
         0   2015-03-29 03:30:00+02:00
         1   2015-03-29 03:30:00+02:00
         dtype: datetime64[ns, Europe/Warsaw]
-        """
+        """  # noqa: E501
         nonexistent_options = ("raise", "NaT", "shift_forward", "shift_backward")
         if nonexistent not in nonexistent_options and not isinstance(
             nonexistent, timedelta
diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py
index c276750314a34..00a929724ed4c 100644
--- a/pandas/core/indexes/datetimes.py
+++ b/pandas/core/indexes/datetimes.py
@@ -147,7 +147,7 @@ class DatetimeIndex(DatetimeTimedeltaMixin):
         One of pandas date offset strings or corresponding objects. The string
         'infer' can be passed in order to set the frequency of the index as the
         inferred frequency upon creation.
-    tz : pytz.timezone or dateutil.tz.tzfile or datetime.tzinfo or str
+    tz : zoneinfo.ZoneInfo, pytz.timezone, dateutil.tz.tzfile, datetime.tzinfo or str
         Set the Timezone of the data.
     ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise'
         When clocks moved backward due to DST, ambiguous times may arise.
diff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py
index f9807310460b4..cfc93ecae295d 100644
--- a/pandas/tests/arithmetic/test_datetime64.py
+++ b/pandas/tests/arithmetic/test_datetime64.py
@@ -5,6 +5,7 @@
     datetime,
     time,
     timedelta,
+    timezone,
 )
 from itertools import (
     product,
@@ -14,7 +15,6 @@
 
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs.tslibs.conversion import localize_pydatetime
 from pandas._libs.tslibs.offsets import shift_months
@@ -1870,8 +1870,10 @@ def test_dt64tz_series_sub_dtitz(self):
 
     def test_sub_datetime_compat(self, unit):
         # see GH#14088
-        ser = Series([datetime(2016, 8, 23, 12, tzinfo=pytz.utc), NaT]).dt.as_unit(unit)
-        dt = datetime(2016, 8, 22, 12, tzinfo=pytz.utc)
+        ser = Series([datetime(2016, 8, 23, 12, tzinfo=timezone.utc), NaT]).dt.as_unit(
+            unit
+        )
+        dt = datetime(2016, 8, 22, 12, tzinfo=timezone.utc)
         # The datetime object has "us" so we upcast lower units
         exp_unit = tm.get_finest_unit(unit, "us")
         exp = Series([Timedelta("1 days"), NaT]).dt.as_unit(exp_unit)
diff --git a/pandas/tests/arrays/test_array.py b/pandas/tests/arrays/test_array.py
index 97d57163ed079..f7b76e7388ae9 100644
--- a/pandas/tests/arrays/test_array.py
+++ b/pandas/tests/arrays/test_array.py
@@ -1,9 +1,9 @@
 import datetime
 import decimal
+import zoneinfo
 
 import numpy as np
 import pytest
-import pytz
 
 import pandas as pd
 import pandas._testing as tm
@@ -285,9 +285,6 @@ def test_array_copy():
     assert tm.shares_memory(a, b)
 
 
-cet = pytz.timezone("CET")
-
-
 @pytest.mark.parametrize(
     "data, expected",
     [
@@ -326,11 +323,18 @@ def test_array_copy():
         ),
         (
             [
-                datetime.datetime(2000, 1, 1, tzinfo=cet),
-                datetime.datetime(2001, 1, 1, tzinfo=cet),
+                datetime.datetime(
+                    2000, 1, 1, tzinfo=zoneinfo.ZoneInfo("Europe/Berlin")
+                ),
+                datetime.datetime(
+                    2001, 1, 1, tzinfo=zoneinfo.ZoneInfo("Europe/Berlin")
+                ),
             ],
             DatetimeArray._from_sequence(
-                ["2000", "2001"], dtype=pd.DatetimeTZDtype(tz=cet, unit="us")
+                ["2000", "2001"],
+                dtype=pd.DatetimeTZDtype(
+                    tz=zoneinfo.ZoneInfo("Europe/Berlin"), unit="us"
+                ),
             ),
         ),
         # timedelta
diff --git a/pandas/tests/arrays/test_datetimes.py b/pandas/tests/arrays/test_datetimes.py
index 63d60c78da482..0a00264a7156f 100644
--- a/pandas/tests/arrays/test_datetimes.py
+++ b/pandas/tests/arrays/test_datetimes.py
@@ -7,12 +7,6 @@
 from datetime import timedelta
 import operator
 
-try:
-    from zoneinfo import ZoneInfo
-except ImportError:
-    # Cannot assign to a type
-    ZoneInfo = None  # type: ignore[misc, assignment]
-
 import numpy as np
 import pytest
 
@@ -724,21 +718,14 @@ def test_tz_localize_t2d(self):
         roundtrip = expected.tz_localize("US/Pacific")
         tm.assert_datetime_array_equal(roundtrip, dta)
 
-    easts = ["US/Eastern", "dateutil/US/Eastern"]
-    if ZoneInfo is not None:
-        try:
-            tz = ZoneInfo("US/Eastern")
-        except KeyError:
-            # no tzdata
-            pass
-        else:
-            # Argument 1 to "append" of "list" has incompatible type "ZoneInfo";
-            # expected "str"
-            easts.append(tz)  # type: ignore[arg-type]
-
-    @pytest.mark.parametrize("tz", easts)
+    @pytest.mark.parametrize(
+        "tz", ["US/Eastern", "dateutil/US/Eastern", "pytz/US/Eastern"]
+    )
     def test_iter_zoneinfo_fold(self, tz):
         # GH#49684
+        if tz.startswith("pytz/"):
+            pytz = pytest.importorskip("pytz")
+            tz = pytz.timezone(tz.removeprefix("pytz/"))
         utc_vals = np.array(
             [1320552000, 1320555600, 1320559200, 1320562800], dtype=np.int64
         )
diff --git a/pandas/tests/dtypes/test_dtypes.py b/pandas/tests/dtypes/test_dtypes.py
index c6da01636247d..252fc484a8246 100644
--- a/pandas/tests/dtypes/test_dtypes.py
+++ b/pandas/tests/dtypes/test_dtypes.py
@@ -3,7 +3,6 @@
 
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
 
@@ -391,8 +390,9 @@ def test_empty(self):
 
     def test_tz_standardize(self):
         # GH 24713
+        pytz = pytest.importorskip("pytz")
         tz = pytz.timezone("US/Eastern")
-        dr = date_range("2013-01-01", periods=3, tz="US/Eastern")
+        dr = date_range("2013-01-01", periods=3, tz=tz)
         dtype = DatetimeTZDtype("ns", dr.tz)
         assert dtype.tz == tz
         dtype = DatetimeTZDtype("ns", dr[0].tz)
diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py
index db18cd4aef14e..b1d7c701e1267 100644
--- a/pandas/tests/dtypes/test_inference.py
+++ b/pandas/tests/dtypes/test_inference.py
@@ -12,6 +12,7 @@
     datetime,
     time,
     timedelta,
+    timezone,
 )
 from decimal import Decimal
 from fractions import Fraction
@@ -27,7 +28,6 @@
 
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs import (
     lib,
@@ -1022,7 +1022,7 @@ def test_maybe_convert_objects_itemsize(self, data0, data1):
 
     def test_mixed_dtypes_remain_object_array(self):
         # GH14956
-        arr = np.array([datetime(2015, 1, 1, tzinfo=pytz.utc), 1], dtype=object)
+        arr = np.array([datetime(2015, 1, 1, tzinfo=timezone.utc), 1], dtype=object)
         result = lib.maybe_convert_objects(arr, convert_non_numeric=True)
         tm.assert_numpy_array_equal(result, arr)
 
diff --git a/pandas/tests/frame/constructors/test_from_records.py b/pandas/tests/frame/constructors/test_from_records.py
index 35e143fcedf7b..5be42d41af03a 100644
--- a/pandas/tests/frame/constructors/test_from_records.py
+++ b/pandas/tests/frame/constructors/test_from_records.py
@@ -1,10 +1,12 @@
 from collections.abc import Iterator
-from datetime import datetime
+from datetime import (
+    datetime,
+    timezone,
+)
 from decimal import Decimal
 
 import numpy as np
 import pytest
-import pytz
 
 from pandas._config import using_pyarrow_string_dtype
 
@@ -239,7 +241,7 @@ def test_from_records_series_categorical_index(self):
         tm.assert_frame_equal(frame, expected)
 
     def test_frame_from_records_utc(self):
-        rec = {"datum": 1.5, "begin_time": datetime(2006, 4, 27, tzinfo=pytz.utc)}
+        rec = {"datum": 1.5, "begin_time": datetime(2006, 4, 27, tzinfo=timezone.utc)}
 
         # it works
         DataFrame.from_records([rec], index="begin_time")
diff --git a/pandas/tests/frame/methods/test_at_time.py b/pandas/tests/frame/methods/test_at_time.py
index 126899826fac3..b69db80dee446 100644
--- a/pandas/tests/frame/methods/test_at_time.py
+++ b/pandas/tests/frame/methods/test_at_time.py
@@ -1,8 +1,11 @@
-from datetime import time
+from datetime import (
+    time,
+    timezone,
+)
+import zoneinfo
 
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs.tslibs import timezones
 
@@ -65,7 +68,7 @@ def test_at_time_nonexistent(self, frame_or_series):
         assert len(rs) == 0
 
     @pytest.mark.parametrize(
-        "hour", ["1:00", "1:00AM", time(1), time(1, tzinfo=pytz.UTC)]
+        "hour", ["1:00", "1:00AM", time(1), time(1, tzinfo=timezone.utc)]
     )
     def test_at_time_errors(self, hour):
         # GH#24043
@@ -83,7 +86,7 @@ def test_at_time_tz(self):
         # GH#24043
         dti = date_range("2018", periods=3, freq="h", tz="US/Pacific")
         df = DataFrame(list(range(len(dti))), index=dti)
-        result = df.at_time(time(4, tzinfo=pytz.timezone("US/Eastern")))
+        result = df.at_time(time(4, tzinfo=zoneinfo.ZoneInfo("US/Eastern")))
         expected = df.iloc[1:2]
         tm.assert_frame_equal(result, expected)
 
diff --git a/pandas/tests/frame/methods/test_join.py b/pandas/tests/frame/methods/test_join.py
index 82802dd6e99eb..7de87e633cfb1 100644
--- a/pandas/tests/frame/methods/test_join.py
+++ b/pandas/tests/frame/methods/test_join.py
@@ -1,4 +1,5 @@
 from datetime import datetime
+import zoneinfo
 
 import numpy as np
 import pytest
@@ -543,17 +544,14 @@ def test_merge_join_different_levels_raises(self):
             df1.join(df2, on="a")
 
     def test_frame_join_tzaware(self):
+        tz = zoneinfo.ZoneInfo("US/Central")
         test1 = DataFrame(
             np.zeros((6, 3)),
-            index=date_range(
-                "2012-11-15 00:00:00", periods=6, freq="100ms", tz="US/Central"
-            ),
+            index=date_range("2012-11-15 00:00:00", periods=6, freq="100ms", tz=tz),
         )
         test2 = DataFrame(
             np.zeros((3, 3)),
-            index=date_range(
-                "2012-11-15 00:00:00", periods=3, freq="250ms", tz="US/Central"
-            ),
+            index=date_range("2012-11-15 00:00:00", periods=3, freq="250ms", tz=tz),
             columns=range(3, 6),
         )
 
@@ -561,4 +559,4 @@ def test_frame_join_tzaware(self):
         expected = test1.index.union(test2.index)
 
         tm.assert_index_equal(result.index, expected)
-        assert result.index.tz.zone == "US/Central"
+        assert result.index.tz.key == "US/Central"
diff --git a/pandas/tests/frame/methods/test_to_dict.py b/pandas/tests/frame/methods/test_to_dict.py
index 0272b679e85a2..c43d947b4877e 100644
--- a/pandas/tests/frame/methods/test_to_dict.py
+++ b/pandas/tests/frame/methods/test_to_dict.py
@@ -2,11 +2,13 @@
     OrderedDict,
     defaultdict,
 )
-from datetime import datetime
+from datetime import (
+    datetime,
+    timezone,
+)
 
 import numpy as np
 import pytest
-import pytz
 
 from pandas import (
     NA,
@@ -209,15 +211,15 @@ def test_to_dict_tz(self):
         # GH#18372 When converting to dict with orient='records' columns of
         # datetime that are tz-aware were not converted to required arrays
         data = [
-            (datetime(2017, 11, 18, 21, 53, 0, 219225, tzinfo=pytz.utc),),
-            (datetime(2017, 11, 18, 22, 6, 30, 61810, tzinfo=pytz.utc),),
+            (datetime(2017, 11, 18, 21, 53, 0, 219225, tzinfo=timezone.utc),),
+            (datetime(2017, 11, 18, 22, 6, 30, 61810, tzinfo=timezone.utc),),
         ]
         df = DataFrame(list(data), columns=["d"])
 
         result = df.to_dict(orient="records")
         expected = [
-            {"d": Timestamp("2017-11-18 21:53:00.219225+0000", tz=pytz.utc)},
-            {"d": Timestamp("2017-11-18 22:06:30.061810+0000", tz=pytz.utc)},
+            {"d": Timestamp("2017-11-18 21:53:00.219225+0000", tz=timezone.utc)},
+            {"d": Timestamp("2017-11-18 22:06:30.061810+0000", tz=timezone.utc)},
         ]
         tm.assert_dict_equal(result[0], expected[0])
         tm.assert_dict_equal(result[1], expected[1])
diff --git a/pandas/tests/frame/methods/test_tz_convert.py b/pandas/tests/frame/methods/test_tz_convert.py
index e9209f218bca9..5ee4021102f22 100644
--- a/pandas/tests/frame/methods/test_tz_convert.py
+++ b/pandas/tests/frame/methods/test_tz_convert.py
@@ -1,3 +1,5 @@
+import zoneinfo
+
 import numpy as np
 import pytest
 
@@ -13,28 +15,34 @@
 
 class TestTZConvert:
     def test_tz_convert(self, frame_or_series):
-        rng = date_range("1/1/2011", periods=200, freq="D", tz="US/Eastern")
+        rng = date_range(
+            "1/1/2011", periods=200, freq="D", tz=zoneinfo.ZoneInfo("US/Eastern")
+        )
 
         obj = DataFrame({"a": 1}, index=rng)
         obj = tm.get_obj(obj, frame_or_series)
 
-        result = obj.tz_convert("Europe/Berlin")
-        expected = DataFrame({"a": 1}, rng.tz_convert("Europe/Berlin"))
+        berlin = zoneinfo.ZoneInfo("Europe/Berlin")
+        result = obj.tz_convert(berlin)
+        expected = DataFrame({"a": 1}, rng.tz_convert(berlin))
         expected = tm.get_obj(expected, frame_or_series)
 
-        assert result.index.tz.zone == "Europe/Berlin"
+        assert result.index.tz.key == "Europe/Berlin"
         tm.assert_equal(result, expected)
 
     def test_tz_convert_axis1(self):
-        rng = date_range("1/1/2011", periods=200, freq="D", tz="US/Eastern")
+        rng = date_range(
+            "1/1/2011", periods=200, freq="D", tz=zoneinfo.ZoneInfo("US/Eastern")
+        )
 
         obj = DataFrame({"a": 1}, index=rng)
 
         obj = obj.T
-        result = obj.tz_convert("Europe/Berlin", axis=1)
-        assert result.columns.tz.zone == "Europe/Berlin"
+        berlin = zoneinfo.ZoneInfo("Europe/Berlin")
+        result = obj.tz_convert(berlin, axis=1)
+        assert result.columns.tz.key == "Europe/Berlin"
 
-        expected = DataFrame({"a": 1}, rng.tz_convert("Europe/Berlin"))
+        expected = DataFrame({"a": 1}, rng.tz_convert(berlin))
 
         tm.assert_equal(result, expected.T)
 
diff --git a/pandas/tests/frame/test_alter_axes.py b/pandas/tests/frame/test_alter_axes.py
index c68171ab254c7..b4c16b94fcf8b 100644
--- a/pandas/tests/frame/test_alter_axes.py
+++ b/pandas/tests/frame/test_alter_axes.py
@@ -1,6 +1,7 @@
-from datetime import datetime
-
-import pytz
+from datetime import (
+    datetime,
+    timezone,
+)
 
 from pandas import DataFrame
 import pandas._testing as tm
@@ -13,7 +14,7 @@ def test_set_axis_setattr_index(self):
         # GH 6785
         # set the index manually
 
-        df = DataFrame([{"ts": datetime(2014, 4, 1, tzinfo=pytz.utc), "foo": 1}])
+        df = DataFrame([{"ts": datetime(2014, 4, 1, tzinfo=timezone.utc), "foo": 1}])
         expected = df.set_index("ts")
         df.index = df["ts"]
         df.pop("ts")
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index da0504458cf5d..c0b9e6549c4ba 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -14,12 +14,12 @@
 )
 import functools
 import re
+import zoneinfo
 
 import numpy as np
 from numpy import ma
 from numpy.ma import mrecords
 import pytest
-import pytz
 
 from pandas._config import using_pyarrow_string_dtype
 
@@ -1908,8 +1908,7 @@ def test_constructor_with_datetimes2(self):
     def test_constructor_with_datetimes3(self):
         # GH 7594
         # don't coerce tz-aware
-        tz = pytz.timezone("US/Eastern")
-        dt = tz.localize(datetime(2012, 1, 1))
+        dt = datetime(2012, 1, 1, tzinfo=zoneinfo.ZoneInfo("US/Eastern"))
 
         df = DataFrame({"End Date": dt}, index=[0])
         assert df.iat[0, 0] == dt
diff --git a/pandas/tests/groupby/test_timegrouper.py b/pandas/tests/groupby/test_timegrouper.py
index ea556d043be2d..44e8e050cb756 100644
--- a/pandas/tests/groupby/test_timegrouper.py
+++ b/pandas/tests/groupby/test_timegrouper.py
@@ -5,11 +5,11 @@
 from datetime import (
     datetime,
     timedelta,
+    timezone,
 )
 
 import numpy as np
 import pytest
-import pytz
 
 import pandas as pd
 from pandas import (
@@ -774,12 +774,12 @@ def test_groupby_with_timezone_selection(self):
     def test_timezone_info(self):
         # see gh-11682: Timezone info lost when broadcasting
         # scalar datetime to DataFrame
-
-        df = DataFrame({"a": [1], "b": [datetime.now(pytz.utc)]})
-        assert df["b"][0].tzinfo == pytz.utc
+        utc = timezone.utc
+        df = DataFrame({"a": [1], "b": [datetime.now(utc)]})
+        assert df["b"][0].tzinfo == utc
         df = DataFrame({"a": [1, 2, 3]})
-        df["b"] = datetime.now(pytz.utc)
-        assert df["b"][0].tzinfo == pytz.utc
+        df["b"] = datetime.now(utc)
+        assert df["b"][0].tzinfo == utc
 
     def test_datetime_count(self):
         df = DataFrame(
diff --git a/pandas/tests/indexes/datetimes/methods/test_astype.py b/pandas/tests/indexes/datetimes/methods/test_astype.py
index c0bc6601769b1..81dc3b3ecc45e 100644
--- a/pandas/tests/indexes/datetimes/methods/test_astype.py
+++ b/pandas/tests/indexes/datetimes/methods/test_astype.py
@@ -3,7 +3,6 @@
 import dateutil
 import numpy as np
 import pytest
-import pytz
 
 import pandas as pd
 from pandas import (
@@ -251,6 +250,8 @@ def _check_rng(rng):
         _check_rng(rng_utc)
 
     def test_index_convert_to_datetime_array_explicit_pytz(self):
+        pytz = pytest.importorskip("pytz")
+
         def _check_rng(rng):
             converted = rng.to_pydatetime()
             assert isinstance(converted, np.ndarray)
diff --git a/pandas/tests/indexes/datetimes/methods/test_insert.py b/pandas/tests/indexes/datetimes/methods/test_insert.py
index ebfe490e0e067..4a5b7bcc1a86f 100644
--- a/pandas/tests/indexes/datetimes/methods/test_insert.py
+++ b/pandas/tests/indexes/datetimes/methods/test_insert.py
@@ -1,8 +1,8 @@
 from datetime import datetime
+import zoneinfo
 
 import numpy as np
 import pytest
-import pytz
 
 from pandas import (
     NA,
@@ -133,49 +133,59 @@ def test_insert3(self, unit):
         assert result.name == expected.name
         assert result.freq is None
 
-    def test_insert4(self, unit):
-        for tz in ["US/Pacific", "Asia/Singapore"]:
-            idx = date_range(
-                "1/1/2000 09:00", periods=6, freq="h", tz=tz, name="idx", unit=unit
-            )
-            # preserve freq
-            expected = date_range(
-                "1/1/2000 09:00", periods=7, freq="h", tz=tz, name="idx", unit=unit
-            )
-            for d in [
-                Timestamp("2000-01-01 15:00", tz=tz),
-                pytz.timezone(tz).localize(datetime(2000, 1, 1, 15)),
-            ]:
-                result = idx.insert(6, d)
-                tm.assert_index_equal(result, expected)
-                assert result.name == expected.name
-                assert result.freq == expected.freq
-                assert result.tz == expected.tz
-
-            expected = DatetimeIndex(
-                [
-                    "2000-01-01 09:00",
-                    "2000-01-01 10:00",
-                    "2000-01-01 11:00",
-                    "2000-01-01 12:00",
-                    "2000-01-01 13:00",
-                    "2000-01-01 14:00",
-                    "2000-01-01 10:00",
-                ],
-                name="idx",
-                tz=tz,
-                freq=None,
-            ).as_unit(unit)
-            # reset freq to None
-            for d in [
-                Timestamp("2000-01-01 10:00", tz=tz),
-                pytz.timezone(tz).localize(datetime(2000, 1, 1, 10)),
-            ]:
-                result = idx.insert(6, d)
-                tm.assert_index_equal(result, expected)
-                assert result.name == expected.name
-                assert result.tz == expected.tz
-                assert result.freq is None
+    @pytest.mark.parametrize("tz", ["US/Pacific", "Asia/Singapore"])
+    @pytest.mark.parametrize(
+        "to_ts",
+        [lambda x: x, lambda x: x.to_pydatetime()],
+        ids=["Timestamp", "datetime"],
+    )
+    def test_insert4(self, unit, tz, to_ts):
+        idx = date_range(
+            "1/1/2000 09:00", periods=6, freq="h", tz=tz, name="idx", unit=unit
+        )
+        # preserve freq
+        expected = date_range(
+            "1/1/2000 09:00", periods=7, freq="h", tz=tz, name="idx", unit=unit
+        )
+        tz = zoneinfo.ZoneInfo(tz)
+        d = to_ts(Timestamp("2000-01-01 15:00", tz=tz))
+        result = idx.insert(6, d)
+        tm.assert_index_equal(result, expected)
+        assert result.name == expected.name
+        assert result.freq == expected.freq
+        assert result.tz == expected.tz
+
+    @pytest.mark.parametrize("tz", ["US/Pacific", "Asia/Singapore"])
+    @pytest.mark.parametrize(
+        "to_ts",
+        [lambda x: x, lambda x: x.to_pydatetime()],
+        ids=["Timestamp", "datetime"],
+    )
+    def test_insert4_no_freq(self, unit, tz, to_ts):
+        idx = date_range(
+            "1/1/2000 09:00", periods=6, freq="h", tz=tz, name="idx", unit=unit
+        )
+        expected = DatetimeIndex(
+            [
+                "2000-01-01 09:00",
+                "2000-01-01 10:00",
+                "2000-01-01 11:00",
+                "2000-01-01 12:00",
+                "2000-01-01 13:00",
+                "2000-01-01 14:00",
+                "2000-01-01 10:00",
+            ],
+            name="idx",
+            tz=tz,
+            freq=None,
+        ).as_unit(unit)
+        # reset freq to None
+        d = to_ts(Timestamp("2000-01-01 10:00", tz=tz))
+        result = idx.insert(6, d)
+        tm.assert_index_equal(result, expected)
+        assert result.name == expected.name
+        assert result.tz == expected.tz
+        assert result.freq is None
 
     # TODO: also changes DataFrame.__setitem__ with expansion
     def test_insert_mismatched_tzawareness(self):
@@ -214,7 +224,7 @@ def test_insert_mismatched_tz(self):
         assert expected.dtype == idx.dtype
         tm.assert_index_equal(result, expected)
 
-        item = datetime(2000, 1, 4, tzinfo=pytz.timezone("US/Eastern"))
+        item = datetime(2000, 1, 4, tzinfo=zoneinfo.ZoneInfo("US/Eastern"))
         result = idx.insert(3, item)
         expected = Index(
             list(idx[:3]) + [item.astimezone(idx.tzinfo)] + list(idx[3:]),
diff --git a/pandas/tests/indexes/datetimes/methods/test_shift.py b/pandas/tests/indexes/datetimes/methods/test_shift.py
index 375dea01974bb..a202627550cd2 100644
--- a/pandas/tests/indexes/datetimes/methods/test_shift.py
+++ b/pandas/tests/indexes/datetimes/methods/test_shift.py
@@ -1,7 +1,7 @@
 from datetime import datetime
+import zoneinfo
 
 import pytest
-import pytz
 
 from pandas.errors import NullFrequencyError
 
@@ -13,8 +13,6 @@
 )
 import pandas._testing as tm
 
-START, END = datetime(2009, 1, 1), datetime(2010, 1, 1)
-
 
 class TestDatetimeIndexShift:
     # -------------------------------------------------------------
@@ -122,24 +120,28 @@ def test_dti_shift_across_dst(self, unit):
     )
     def test_dti_shift_near_midnight(self, shift, result_time, unit):
         # GH 8616
-        dt = datetime(2014, 11, 14, 0)
-        dt_est = pytz.timezone("EST").localize(dt)
+        tz = zoneinfo.ZoneInfo("US/Eastern")
+        dt_est = datetime(2014, 11, 14, 0, tzinfo=tz)
         idx = DatetimeIndex([dt_est]).as_unit(unit)
         ser = Series(data=[1], index=idx)
         result = ser.shift(shift, freq="h")
-        exp_index = DatetimeIndex([result_time], tz="EST").as_unit(unit)
+        exp_index = DatetimeIndex([result_time], tz=tz).as_unit(unit)
         expected = Series(1, index=exp_index)
         tm.assert_series_equal(result, expected)
 
     def test_shift_periods(self, unit):
         # GH#22458 : argument 'n' was deprecated in favor of 'periods'
-        idx = date_range(start=START, end=END, periods=3, unit=unit)
+        idx = date_range(
+            start=datetime(2009, 1, 1), end=datetime(2010, 1, 1), periods=3, unit=unit
+        )
         tm.assert_index_equal(idx.shift(periods=0), idx)
         tm.assert_index_equal(idx.shift(0), idx)
 
     @pytest.mark.parametrize("freq", ["B", "C"])
     def test_shift_bday(self, freq, unit):
-        rng = date_range(START, END, freq=freq, unit=unit)
+        rng = date_range(
+            datetime(2009, 1, 1), datetime(2010, 1, 1), freq=freq, unit=unit
+        )
         shifted = rng.shift(5)
         assert shifted[0] == rng[5]
         assert shifted.freq == rng.freq
@@ -153,11 +155,21 @@ def test_shift_bday(self, freq, unit):
         assert shifted.freq == rng.freq
 
     def test_shift_bmonth(self, performance_warning, unit):
-        rng = date_range(START, END, freq=pd.offsets.BMonthEnd(), unit=unit)
+        rng = date_range(
+            datetime(2009, 1, 1),
+            datetime(2010, 1, 1),
+            freq=pd.offsets.BMonthEnd(),
+            unit=unit,
+        )
         shifted = rng.shift(1, freq=pd.offsets.BDay())
         assert shifted[0] == rng[0] + pd.offsets.BDay()
 
-        rng = date_range(START, END, freq=pd.offsets.BMonthEnd(), unit=unit)
+        rng = date_range(
+            datetime(2009, 1, 1),
+            datetime(2010, 1, 1),
+            freq=pd.offsets.BMonthEnd(),
+            unit=unit,
+        )
         with tm.assert_produces_warning(performance_warning):
             shifted = rng.shift(1, freq=pd.offsets.CDay())
             assert shifted[0] == rng[0] + pd.offsets.CDay()
diff --git a/pandas/tests/indexes/datetimes/methods/test_to_period.py b/pandas/tests/indexes/datetimes/methods/test_to_period.py
index 8e279162b7012..cd4a142dd5b30 100644
--- a/pandas/tests/indexes/datetimes/methods/test_to_period.py
+++ b/pandas/tests/indexes/datetimes/methods/test_to_period.py
@@ -1,7 +1,8 @@
+from datetime import timezone
+
 import dateutil.tz
 from dateutil.tz import tzlocal
 import pytest
-import pytz
 
 from pandas._libs.tslibs.ccalendar import MONTHS
 from pandas._libs.tslibs.offsets import MonthEnd
@@ -155,7 +156,13 @@ def test_to_period_microsecond(self):
 
     @pytest.mark.parametrize(
         "tz",
-        ["US/Eastern", pytz.utc, tzlocal(), "dateutil/US/Eastern", dateutil.tz.tzutc()],
+        [
+            "US/Eastern",
+            timezone.utc,
+            tzlocal(),
+            "dateutil/US/Eastern",
+            dateutil.tz.tzutc(),
+        ],
     )
     def test_to_period_tz(self, tz):
         ts = date_range("1/1/2000", "2/1/2000", tz=tz)
diff --git a/pandas/tests/indexes/datetimes/methods/test_tz_convert.py b/pandas/tests/indexes/datetimes/methods/test_tz_convert.py
index b2cf488ac8313..9eabb742b93a4 100644
--- a/pandas/tests/indexes/datetimes/methods/test_tz_convert.py
+++ b/pandas/tests/indexes/datetimes/methods/test_tz_convert.py
@@ -4,7 +4,6 @@
 from dateutil.tz import gettz
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs.tslibs import timezones
 
@@ -260,11 +259,14 @@ def test_dti_tz_convert_tzlocal(self):
         [
             "US/Eastern",
             "dateutil/US/Eastern",
-            pytz.timezone("US/Eastern"),
+            "pytz/US/Eastern",
             gettz("US/Eastern"),
         ],
     )
     def test_dti_tz_convert_utc_to_local_no_modify(self, tz):
+        if isinstance(tz, str) and tz.startswith("pytz/"):
+            pytz = pytest.importorskip("pytz")
+            tz = pytz.timezone(tz.removeprefix("pytz/"))
         rng = date_range("3/11/2012", "3/12/2012", freq="h", tz="utc")
         rng_eastern = rng.tz_convert(tz)
 
diff --git a/pandas/tests/indexes/datetimes/methods/test_tz_localize.py b/pandas/tests/indexes/datetimes/methods/test_tz_localize.py
index ad7769c6b9671..c6697fd169e8a 100644
--- a/pandas/tests/indexes/datetimes/methods/test_tz_localize.py
+++ b/pandas/tests/indexes/datetimes/methods/test_tz_localize.py
@@ -1,7 +1,9 @@
 from datetime import (
     datetime,
     timedelta,
+    timezone,
 )
+from zoneinfo import ZoneInfo
 
 import dateutil.tz
 from dateutil.tz import gettz
@@ -19,22 +21,13 @@
 )
 import pandas._testing as tm
 
-try:
-    from zoneinfo import ZoneInfo
-except ImportError:
-    # Cannot assign to a type  [misc]
-    ZoneInfo = None  # type: ignore[misc, assignment]
 
-
-easts = [pytz.timezone("US/Eastern"), gettz("US/Eastern")]
-if ZoneInfo is not None:
-    try:
-        tz = ZoneInfo("US/Eastern")
-    except KeyError:
-        # no tzdata
-        pass
-    else:
-        easts.append(tz)
+@pytest.fixture(params=["pytz/US/Eastern", gettz("US/Eastern"), ZoneInfo("US/Eastern")])
+def tz(request):
+    if isinstance(request.param, str) and request.param.startswith("pytz/"):
+        pytz = pytest.importorskip("pytz")
+        return pytz.timezone(request.param.removeprefix("pytz/"))
+    return request.param
 
 
 class TestTZLocalize:
@@ -88,7 +81,6 @@ def test_dti_tz_localize_nonexistent_raise_coerce(self):
         expected = dti.tz_convert("US/Eastern")
         tm.assert_index_equal(result, expected)
 
-    @pytest.mark.parametrize("tz", easts)
     def test_dti_tz_localize_ambiguous_infer(self, tz):
         # November 6, 2011, fall back, repeat 2 AM hour
         # With no repeated hours, we cannot infer the transition
@@ -96,7 +88,6 @@ def test_dti_tz_localize_ambiguous_infer(self, tz):
         with pytest.raises(pytz.AmbiguousTimeError, match="Cannot infer dst time"):
             dr.tz_localize(tz)
 
-    @pytest.mark.parametrize("tz", easts)
     def test_dti_tz_localize_ambiguous_infer2(self, tz, unit):
         # With repeated hours, we can infer the transition
         dr = date_range(
@@ -116,7 +107,6 @@ def test_dti_tz_localize_ambiguous_infer2(self, tz, unit):
         result2 = DatetimeIndex(times, tz=tz, ambiguous="infer").as_unit(unit)
         tm.assert_index_equal(result2, expected)
 
-    @pytest.mark.parametrize("tz", easts)
     def test_dti_tz_localize_ambiguous_infer3(self, tz):
         # When there is no dst transition, nothing special happens
         dr = date_range(datetime(2011, 6, 1, 0), periods=10, freq=offsets.Hour())
@@ -124,7 +114,6 @@ def test_dti_tz_localize_ambiguous_infer3(self, tz):
         localized_infer = dr.tz_localize(tz, ambiguous="infer")
         tm.assert_index_equal(localized, localized_infer)
 
-    @pytest.mark.parametrize("tz", easts)
     def test_dti_tz_localize_ambiguous_times(self, tz):
         # March 13, 2011, spring forward, skip from 2 AM to 3 AM
         dr = date_range(datetime(2011, 3, 13, 1, 30), periods=3, freq=offsets.Hour())
@@ -143,7 +132,7 @@ def test_dti_tz_localize_ambiguous_times(self, tz):
 
         # UTC is OK
         dr = date_range(
-            datetime(2011, 3, 13), periods=48, freq=offsets.Minute(30), tz=pytz.utc
+            datetime(2011, 3, 13), periods=48, freq=offsets.Minute(30), tz=timezone.utc
         )
 
     @pytest.mark.parametrize("tzstr", ["US/Eastern", "dateutil/US/Eastern"])
@@ -181,15 +170,6 @@ def test_dti_tz_localize(self, prefix):
         with pytest.raises(pytz.NonExistentTimeError, match="2011-03-13 02:00:00"):
             dti.tz_localize(tzstr)
 
-    @pytest.mark.parametrize(
-        "tz",
-        [
-            "US/Eastern",
-            "dateutil/US/Eastern",
-            pytz.timezone("US/Eastern"),
-            gettz("US/Eastern"),
-        ],
-    )
     def test_dti_tz_localize_utc_conversion(self, tz):
         # Localizing to time zone should:
         #  1) check for DST ambiguities
@@ -245,7 +225,6 @@ def test_dti_tz_localize_tzlocal(self):
         dti2 = dti.tz_localize(None)
         tm.assert_numpy_array_equal(dti2.asi8 - offset, dti.asi8)
 
-    @pytest.mark.parametrize("tz", easts)
     def test_dti_tz_localize_ambiguous_nat(self, tz):
         times = [
             "11/06/2011 00:00",
@@ -270,7 +249,6 @@ def test_dti_tz_localize_ambiguous_nat(self, tz):
         # right is datetime64[ns, tzfile('/usr/share/zoneinfo/US/Eastern')]
         tm.assert_numpy_array_equal(di_test.values, localized.values)
 
-    @pytest.mark.parametrize("tz", easts)
     def test_dti_tz_localize_ambiguous_flags(self, tz, unit):
         # November 6, 2011, fall back, repeat 2 AM hour
 
@@ -321,8 +299,7 @@ def test_dti_tz_localize_ambiguous_flags(self, tz, unit):
         dr = dr.append(dr)
         tm.assert_index_equal(dr, localized)
 
-    @pytest.mark.parametrize("tz", easts)
-    def test_dti_tz_localize_ambiguous_flags2(self, tz, unit):
+    def test_dti_tz_localize_ambiguous_flags2(self, tz):
         # When there is no dst transition, nothing special happens
         dr = date_range(datetime(2011, 6, 1, 0), periods=10, freq=offsets.Hour())
         is_dst = np.array([1] * 10)
@@ -332,8 +309,8 @@ def test_dti_tz_localize_ambiguous_flags2(self, tz, unit):
 
     def test_dti_tz_localize_bdate_range(self):
         dr = bdate_range("1/1/2009", "1/1/2010")
-        dr_utc = bdate_range("1/1/2009", "1/1/2010", tz=pytz.utc)
-        localized = dr.tz_localize(pytz.utc)
+        dr_utc = bdate_range("1/1/2009", "1/1/2010", tz=timezone.utc)
+        localized = dr.tz_localize(timezone.utc)
         tm.assert_index_equal(dr_utc, localized)
 
     @pytest.mark.parametrize(
diff --git a/pandas/tests/indexes/datetimes/test_constructors.py b/pandas/tests/indexes/datetimes/test_constructors.py
index 43a7cdf63d9b9..aba440ceeb56b 100644
--- a/pandas/tests/indexes/datetimes/test_constructors.py
+++ b/pandas/tests/indexes/datetimes/test_constructors.py
@@ -7,6 +7,7 @@
 )
 from functools import partial
 from operator import attrgetter
+import zoneinfo
 
 import dateutil
 import dateutil.tz
@@ -152,7 +153,9 @@ def test_construction_caching(self):
         df = pd.DataFrame(
             {
                 "dt": date_range("20130101", periods=3),
-                "dttz": date_range("20130101", periods=3, tz="US/Eastern"),
+                "dttz": date_range(
+                    "20130101", periods=3, tz=zoneinfo.ZoneInfo("US/Eastern")
+                ),
                 "dt_with_null": [
                     Timestamp("20130101"),
                     pd.NaT,
@@ -161,7 +164,7 @@ def test_construction_caching(self):
                 "dtns": date_range("20130101", periods=3, freq="ns"),
             }
         )
-        assert df.dttz.dtype.tz.zone == "US/Eastern"
+        assert df.dttz.dtype.tz.key == "US/Eastern"
 
     @pytest.mark.parametrize(
         "kwargs",
@@ -198,7 +201,11 @@ def test_construction_with_alt_tz_localize(self, kwargs, tz_aware_fixture):
         # incompat tz/dtype
         msg = "cannot supply both a tz and a dtype with a tz"
         with pytest.raises(ValueError, match=msg):
-            DatetimeIndex(i.tz_localize(None).asi8, dtype=i.dtype, tz="US/Pacific")
+            DatetimeIndex(
+                i.tz_localize(None).asi8,
+                dtype=i.dtype,
+                tz=zoneinfo.ZoneInfo("US/Hawaii"),
+            )
 
     def test_construction_index_with_mixed_timezones(self):
         # gh-11488: no tz results in DatetimeIndex
@@ -736,7 +743,7 @@ def test_disallow_setting_tz(self):
         dti = DatetimeIndex(["2010"], tz="UTC")
         msg = "Cannot directly set timezone"
         with pytest.raises(AttributeError, match=msg):
-            dti.tz = pytz.timezone("US/Pacific")
+            dti.tz = zoneinfo.ZoneInfo("US/Pacific")
 
     @pytest.mark.parametrize(
         "tz",
@@ -764,7 +771,9 @@ def test_constructor_start_end_with_tz(self, tz):
     @pytest.mark.parametrize("tz", ["US/Pacific", "US/Eastern", "Asia/Tokyo"])
     def test_constructor_with_non_normalized_pytz(self, tz):
         # GH 18595
-        non_norm_tz = Timestamp("2010", tz=tz).tz
+        pytz = pytest.importorskip("pytz")
+        tz_in = pytz.timezone(tz)
+        non_norm_tz = Timestamp("2010", tz=tz_in).tz
         result = DatetimeIndex(["2010"], tz=non_norm_tz)
         assert pytz.timezone(tz) is result.tz
 
@@ -914,7 +923,9 @@ def test_index_constructor_with_numpy_object_array_and_timestamp_tz_with_nan(sel
         expected = DatetimeIndex([Timestamp("2019", tz="UTC"), pd.NaT])
         tm.assert_index_equal(result, expected)
 
-    @pytest.mark.parametrize("tz", [pytz.timezone("US/Eastern"), gettz("US/Eastern")])
+    @pytest.mark.parametrize(
+        "tz", [zoneinfo.ZoneInfo("US/Eastern"), gettz("US/Eastern")]
+    )
     def test_dti_from_tzaware_datetime(self, tz):
         d = [datetime(2012, 8, 19, tzinfo=tz)]
 
@@ -963,7 +974,7 @@ def test_dti_convert_datetime_list(self, tzstr):
     @pytest.mark.parametrize(
         "tz",
         [
-            pytz.timezone("US/Eastern"),
+            "pytz/US/Eastern",
             gettz("US/Eastern"),
         ],
     )
@@ -972,6 +983,8 @@ def test_dti_convert_datetime_list(self, tzstr):
     def test_dti_ambiguous_matches_timestamp(self, tz, use_str, box_cls, request):
         # GH#47471 check that we get the same raising behavior in the DTI
         # constructor and Timestamp constructor
+        if isinstance(tz, str) and tz.startswith("pytz/"):
+            tz = pytz.timezone(tz.removeprefix("pytz/"))
         dtstr = "2013-11-03 01:59:59.999999"
         item = dtstr
         if not use_str:
diff --git a/pandas/tests/indexes/datetimes/test_date_range.py b/pandas/tests/indexes/datetimes/test_date_range.py
index 8bf51bcd38862..ee1c906efea73 100644
--- a/pandas/tests/indexes/datetimes/test_date_range.py
+++ b/pandas/tests/indexes/datetimes/test_date_range.py
@@ -12,7 +12,6 @@
 import numpy as np
 import pytest
 import pytz
-from pytz import timezone
 
 from pandas._libs.tslibs import timezones
 from pandas._libs.tslibs.offsets import (
@@ -97,6 +96,7 @@ def test_date_range_timestamp_equiv_dateutil(self):
         assert ts == stamp
 
     def test_date_range_timestamp_equiv_explicit_pytz(self):
+        pytz = pytest.importorskip("pytz")
         rng = date_range("20090415", "20090519", tz=pytz.timezone("US/Eastern"))
         stamp = rng[0]
 
@@ -490,7 +490,8 @@ def test_range_bug(self, unit):
 
     def test_range_tz_pytz(self):
         # see gh-2906
-        tz = timezone("US/Eastern")
+        pytz = pytest.importorskip("pytz")
+        tz = pytz.timezone("US/Eastern")
         start = tz.localize(datetime(2011, 1, 1))
         end = tz.localize(datetime(2011, 1, 3))
 
@@ -517,14 +518,16 @@ def test_range_tz_pytz(self):
         ],
     )
     def test_range_tz_dst_straddle_pytz(self, start, end):
-        start = Timestamp(start, tz="US/Eastern")
-        end = Timestamp(end, tz="US/Eastern")
+        pytz = pytest.importorskip("pytz")
+        tz = pytz.timezone("US/Eastern")
+        start = Timestamp(start, tz=tz)
+        end = Timestamp(end, tz=tz)
         dr = date_range(start, end, freq="D")
         assert dr[0] == start
         assert dr[-1] == end
         assert np.all(dr.hour == 0)
 
-        dr = date_range(start, end, freq="D", tz="US/Eastern")
+        dr = date_range(start, end, freq="D", tz=tz)
         assert dr[0] == start
         assert dr[-1] == end
         assert np.all(dr.hour == 0)
@@ -533,7 +536,7 @@ def test_range_tz_dst_straddle_pytz(self, start, end):
             start.replace(tzinfo=None),
             end.replace(tzinfo=None),
             freq="D",
-            tz="US/Eastern",
+            tz=tz,
         )
         assert dr[0] == start
         assert dr[-1] == end
diff --git a/pandas/tests/indexes/datetimes/test_formats.py b/pandas/tests/indexes/datetimes/test_formats.py
index 6e4e22942ab07..4551fdf073193 100644
--- a/pandas/tests/indexes/datetimes/test_formats.py
+++ b/pandas/tests/indexes/datetimes/test_formats.py
@@ -1,9 +1,11 @@
-from datetime import datetime
+from datetime import (
+    datetime,
+    timezone,
+)
 
 import dateutil.tz
 import numpy as np
 import pytest
-import pytz
 
 import pandas as pd
 from pandas import (
@@ -276,7 +278,7 @@ def test_dti_summary(self):
             result = idx._summary()
             assert result == expected
 
-    @pytest.mark.parametrize("tz", [None, pytz.utc, dateutil.tz.tzutc()])
+    @pytest.mark.parametrize("tz", [None, timezone.utc, dateutil.tz.tzutc()])
     @pytest.mark.parametrize("freq", ["B", "C"])
     def test_dti_business_repr_etc_smoke(self, tz, freq):
         # only really care that it works
diff --git a/pandas/tests/indexes/datetimes/test_setops.py b/pandas/tests/indexes/datetimes/test_setops.py
index fc3a1d4721841..5290fb0c80b84 100644
--- a/pandas/tests/indexes/datetimes/test_setops.py
+++ b/pandas/tests/indexes/datetimes/test_setops.py
@@ -1,11 +1,11 @@
 from datetime import (
     datetime,
+    timedelta,
     timezone,
 )
 
 import numpy as np
 import pytest
-import pytz
 
 import pandas.util._test_decorators as td
 
@@ -560,6 +560,7 @@ def test_intersection_list(self):
         tm.assert_index_equal(res, idx)
 
     def test_month_range_union_tz_pytz(self, sort):
+        pytz = pytest.importorskip("pytz")
         tz = pytz.timezone("US/Eastern")
 
         early_start = datetime(2011, 1, 1)
@@ -648,7 +649,7 @@ def test_intersection_bug(self):
         assert result.freq == b.freq
 
     @pytest.mark.parametrize(
-        "tz", [None, "UTC", "Europe/Berlin", pytz.FixedOffset(-60)]
+        "tz", [None, "UTC", "Europe/Berlin", timezone(timedelta(hours=-1))]
     )
     def test_intersection_dst_transition(self, tz):
         # GH 46702: Europe/Berlin has DST transition
diff --git a/pandas/tests/indexes/datetimes/test_timezones.py b/pandas/tests/indexes/datetimes/test_timezones.py
index 0c8bdbdd2fb22..e4b8a909add0d 100644
--- a/pandas/tests/indexes/datetimes/test_timezones.py
+++ b/pandas/tests/indexes/datetimes/test_timezones.py
@@ -8,11 +8,11 @@
     timezone,
     tzinfo,
 )
+import zoneinfo
 
 from dateutil.tz import gettz
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs.tslibs import (
     conversion,
@@ -184,8 +184,11 @@ def test_dti_tz_nat(self, tzstr):
         assert isna(idx[1])
         assert idx[0].tzinfo is not None
 
-    @pytest.mark.parametrize("tzstr", ["US/Eastern", "dateutil/US/Eastern"])
+    @pytest.mark.parametrize("tzstr", ["pytz/US/Eastern", "dateutil/US/Eastern"])
     def test_utc_box_timestamp_and_localize(self, tzstr):
+        if tzstr.startswith("pytz/"):
+            pytest.importorskip("pytz")
+            tzstr = tzstr.removeprefix("pytz/")
         tz = timezones.maybe_get_tz(tzstr)
 
         rng = date_range("3/11/2012", "3/12/2012", freq="h", tz="utc")
@@ -206,15 +209,17 @@ def test_utc_box_timestamp_and_localize(self, tzstr):
             rng_eastern[0].tzinfo
         )
 
-    @pytest.mark.parametrize("tz", [pytz.timezone("US/Central"), gettz("US/Central")])
+    @pytest.mark.parametrize(
+        "tz", [zoneinfo.ZoneInfo("US/Central"), gettz("US/Central")]
+    )
     def test_with_tz(self, tz):
         # just want it to work
-        start = datetime(2011, 3, 12, tzinfo=pytz.utc)
+        start = datetime(2011, 3, 12, tzinfo=timezone.utc)
         dr = bdate_range(start, periods=50, freq=pd.offsets.Hour())
-        assert dr.tz is pytz.utc
+        assert dr.tz is timezone.utc
 
         # DateRange with naive datetimes
-        dr = bdate_range("1/1/2005", "1/1/2009", tz=pytz.utc)
+        dr = bdate_range("1/1/2005", "1/1/2009", tz=timezone.utc)
         dr = bdate_range("1/1/2005", "1/1/2009", tz=tz)
 
         # normalized
@@ -231,13 +236,16 @@ def test_with_tz(self, tz):
 
         # datetimes with tzinfo set
         dr = bdate_range(
-            datetime(2005, 1, 1, tzinfo=pytz.utc), datetime(2009, 1, 1, tzinfo=pytz.utc)
+            datetime(2005, 1, 1, tzinfo=timezone.utc),
+            datetime(2009, 1, 1, tzinfo=timezone.utc),
         )
         msg = "Start and end cannot both be tz-aware with different timezones"
         with pytest.raises(Exception, match=msg):
-            bdate_range(datetime(2005, 1, 1, tzinfo=pytz.utc), "1/1/2009", tz=tz)
+            bdate_range(datetime(2005, 1, 1, tzinfo=timezone.utc), "1/1/2009", tz=tz)
 
-    @pytest.mark.parametrize("tz", [pytz.timezone("US/Eastern"), gettz("US/Eastern")])
+    @pytest.mark.parametrize(
+        "tz", [zoneinfo.ZoneInfo("US/Eastern"), gettz("US/Eastern")]
+    )
     def test_dti_convert_tz_aware_datetime_datetime(self, tz):
         # GH#1581
         dates = [datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)]
diff --git a/pandas/tests/indexes/multi/test_reshape.py b/pandas/tests/indexes/multi/test_reshape.py
index 06dbb33aadf97..cc3dadc6bb61c 100644
--- a/pandas/tests/indexes/multi/test_reshape.py
+++ b/pandas/tests/indexes/multi/test_reshape.py
@@ -1,8 +1,8 @@
 from datetime import datetime
+import zoneinfo
 
 import numpy as np
 import pytest
-import pytz
 
 import pandas as pd
 from pandas import (
@@ -114,11 +114,11 @@ def test_append_index():
     result = idx1.append(midx_lv2)
 
     # see gh-7112
-    tz = pytz.timezone("Asia/Tokyo")
+    tz = zoneinfo.ZoneInfo("Asia/Tokyo")
     expected_tuples = [
-        (1.1, tz.localize(datetime(2011, 1, 1))),
-        (1.2, tz.localize(datetime(2011, 1, 2))),
-        (1.3, tz.localize(datetime(2011, 1, 3))),
+        (1.1, datetime(2011, 1, 1, tzinfo=tz)),
+        (1.2, datetime(2011, 1, 2, tzinfo=tz)),
+        (1.3, datetime(2011, 1, 3, tzinfo=tz)),
     ]
     expected = Index([1.1, 1.2, 1.3] + expected_tuples)
     tm.assert_index_equal(result, expected)
@@ -138,9 +138,9 @@ def test_append_index():
     expected = Index._simple_new(
         np.array(
             [
-                (1.1, tz.localize(datetime(2011, 1, 1)), "A"),
-                (1.2, tz.localize(datetime(2011, 1, 2)), "B"),
-                (1.3, tz.localize(datetime(2011, 1, 3)), "C"),
+                (1.1, datetime(2011, 1, 1, tzinfo=tz), "A"),
+                (1.2, datetime(2011, 1, 2, tzinfo=tz), "B"),
+                (1.3, datetime(2011, 1, 3, tzinfo=tz), "C"),
             ]
             + expected_tuples,
             dtype=object,
diff --git a/pandas/tests/io/json/test_ujson.py b/pandas/tests/io/json/test_ujson.py
index 8e05a8e6fc5d8..62118f1c82ebb 100644
--- a/pandas/tests/io/json/test_ujson.py
+++ b/pandas/tests/io/json/test_ujson.py
@@ -10,7 +10,6 @@
 import dateutil
 import numpy as np
 import pytest
-import pytz
 
 import pandas._libs.json as ujson
 from pandas.compat import IS64
@@ -370,6 +369,7 @@ def test_encode_time_conversion_basic(self, test):
 
     def test_encode_time_conversion_pytz(self):
         # see gh-11473: to_json segfaults with timezone-aware datetimes
+        pytz = pytest.importorskip("pytz")
         test = datetime.time(10, 12, 15, 343243, pytz.utc)
         output = ujson.ujson_dumps(test)
         expected = f'"{test.isoformat()}"'
diff --git a/pandas/tests/io/parser/test_parse_dates.py b/pandas/tests/io/parser/test_parse_dates.py
index e9c6c0f5e32d7..ec7e5575b2e7d 100644
--- a/pandas/tests/io/parser/test_parse_dates.py
+++ b/pandas/tests/io/parser/test_parse_dates.py
@@ -12,7 +12,6 @@
 
 import numpy as np
 import pytest
-import pytz
 
 import pandas as pd
 from pandas import (
@@ -217,6 +216,7 @@ def test_parse_tz_aware(all_parsers):
         {"x": [0.5]}, index=Index([Timestamp("2012-06-13 01:39:00+00:00")], name="Date")
     )
     if parser.engine == "pyarrow":
+        pytz = pytest.importorskip("pytz")
         expected_tz = pytz.utc
     else:
         expected_tz = timezone.utc
diff --git a/pandas/tests/io/test_feather.py b/pandas/tests/io/test_feather.py
index 893728748f276..dc82994bcbc7f 100644
--- a/pandas/tests/io/test_feather.py
+++ b/pandas/tests/io/test_feather.py
@@ -1,5 +1,7 @@
 """test feather-format compat"""
 
+import zoneinfo
+
 import numpy as np
 import pytest
 
@@ -62,6 +64,7 @@ def test_error(self):
             self.check_error_on_write(obj, ValueError, msg)
 
     def test_basic(self):
+        tz = zoneinfo.ZoneInfo("US/Eastern")
         df = pd.DataFrame(
             {
                 "string": list("abc"),
@@ -76,7 +79,7 @@ def test_basic(self):
                     list(pd.date_range("20130101", periods=3)), freq=None
                 ),
                 "dttz": pd.DatetimeIndex(
-                    list(pd.date_range("20130101", periods=3, tz="US/Eastern")),
+                    list(pd.date_range("20130101", periods=3, tz=tz)),
                     freq=None,
                 ),
                 "dt_with_null": [
@@ -93,7 +96,7 @@ def test_basic(self):
         df["timedeltas"] = pd.timedelta_range("1 day", periods=3)
         df["intervals"] = pd.interval_range(0, 3, 3)
 
-        assert df.dttz.dtype.tz.zone == "US/Eastern"
+        assert df.dttz.dtype.tz.key == "US/Eastern"
 
         expected = df.copy()
         expected.loc[1, "bool_with_null"] = None
diff --git a/pandas/tests/io/test_parquet.py b/pandas/tests/io/test_parquet.py
index af492b967bc1d..2e8e358b8e3c9 100644
--- a/pandas/tests/io/test_parquet.py
+++ b/pandas/tests/io/test_parquet.py
@@ -1129,9 +1129,11 @@ def test_infer_string_large_string_type(self, tmp_path, pa):
 class TestParquetFastParquet(Base):
     @pytest.mark.xfail(reason="datetime_with_nat gets incorrect values")
     def test_basic(self, fp, df_full):
+        pytz = pytest.importorskip("pytz")
+        tz = pytz.timezone("US/Eastern")
         df = df_full
 
-        dti = pd.date_range("20130101", periods=3, tz="US/Eastern")
+        dti = pd.date_range("20130101", periods=3, tz=tz)
         dti = dti._with_freq(None)  # freq doesn't round-trip
         df["datetime_tz"] = dti
         df["timedelta"] = pd.timedelta_range("1 day", periods=3)
diff --git a/pandas/tests/io/test_pickle.py b/pandas/tests/io/test_pickle.py
index 1420e24858ffb..1520094fdddac 100644
--- a/pandas/tests/io/test_pickle.py
+++ b/pandas/tests/io/test_pickle.py
@@ -111,6 +111,7 @@ def test_flatten_buffer(data):
 
 
 def test_pickles(datapath):
+    pytest.importorskip("pytz")
     if not is_platform_little_endian():
         pytest.skip("known failure on non-little endian")
 
diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py
index 7f37ca6831faa..cf0cbabb0258c 100644
--- a/pandas/tests/resample/test_datetime_index.py
+++ b/pandas/tests/resample/test_datetime_index.py
@@ -1,9 +1,9 @@
 from datetime import datetime
 from functools import partial
+import zoneinfo
 
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs import lib
 from pandas._typing import DatetimeNaTType
@@ -1655,13 +1655,13 @@ def test_resample_dst_anchor2(unit):
 
 def test_downsample_across_dst(unit):
     # GH 8531
-    tz = pytz.timezone("Europe/Berlin")
+    tz = zoneinfo.ZoneInfo("Europe/Berlin")
     dt = datetime(2014, 10, 26)
-    dates = date_range(tz.localize(dt), periods=4, freq="2h").as_unit(unit)
+    dates = date_range(dt.astimezone(tz), periods=4, freq="2h").as_unit(unit)
     result = Series(5, index=dates).resample("h").mean()
     expected = Series(
         [5.0, np.nan] * 3 + [5.0],
-        index=date_range(tz.localize(dt), periods=7, freq="h").as_unit(unit),
+        index=date_range(dt.astimezone(tz), periods=7, freq="h").as_unit(unit),
     )
     tm.assert_series_equal(result, expected)
 
diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py
index a4e27ad46c59c..89a21f0565793 100644
--- a/pandas/tests/resample/test_period_index.py
+++ b/pandas/tests/resample/test_period_index.py
@@ -1,11 +1,14 @@
-from datetime import datetime
+from datetime import (
+    datetime,
+    timezone,
+)
 import re
 import warnings
+import zoneinfo
 
 import dateutil
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs.tslibs.ccalendar import (
     DAYS,
@@ -304,7 +307,7 @@ def test_resample_incompat_freq(self):
     @pytest.mark.parametrize(
         "tz",
         [
-            pytz.timezone("America/Los_Angeles"),
+            zoneinfo.ZoneInfo("America/Los_Angeles"),
             dateutil.tz.gettz("America/Los_Angeles"),
         ],
     )
@@ -312,9 +315,13 @@ def test_with_local_timezone(self, tz):
         # see gh-5430
         local_timezone = tz
 
-        start = datetime(year=2013, month=11, day=1, hour=0, minute=0, tzinfo=pytz.utc)
+        start = datetime(
+            year=2013, month=11, day=1, hour=0, minute=0, tzinfo=timezone.utc
+        )
         # 1 day later
-        end = datetime(year=2013, month=11, day=2, hour=0, minute=0, tzinfo=pytz.utc)
+        end = datetime(
+            year=2013, month=11, day=2, hour=0, minute=0, tzinfo=timezone.utc
+        )
 
         index = date_range(start, end, freq="h", name="idx")
 
@@ -336,7 +343,7 @@ def test_with_local_timezone(self, tz):
     @pytest.mark.parametrize(
         "tz",
         [
-            pytz.timezone("America/Los_Angeles"),
+            zoneinfo.ZoneInfo("America/Los_Angeles"),
             dateutil.tz.gettz("America/Los_Angeles"),
         ],
     )
@@ -353,8 +360,6 @@ def test_resample_with_tz(self, tz, unit):
             index=exp_dti,
         )
         tm.assert_series_equal(result, expected)
-        # Especially assert that the timezone is LMT for pytz
-        assert result.index.tz == tz
 
     def test_resample_nonexistent_time_bin_edge(self):
         # GH 19375
diff --git a/pandas/tests/reshape/concat/test_append_common.py b/pandas/tests/reshape/concat/test_append_common.py
index afafe8f6ab264..d0ff950e7985f 100644
--- a/pandas/tests/reshape/concat/test_append_common.py
+++ b/pandas/tests/reshape/concat/test_append_common.py
@@ -1,3 +1,5 @@
+import zoneinfo
+
 import numpy as np
 import pytest
 
@@ -353,14 +355,15 @@ def test_concatlike_datetimetz_to_object(self, tz_aware_fixture):
         tm.assert_series_equal(res, Series(exp, index=[0, 1, 0, 1]))
 
         # different tz
-        dti3 = pd.DatetimeIndex(["2012-01-01", "2012-01-02"], tz="US/Pacific")
+        tz_diff = zoneinfo.ZoneInfo("US/Hawaii")
+        dti3 = pd.DatetimeIndex(["2012-01-01", "2012-01-02"], tz=tz_diff)
 
         exp = Index(
             [
                 pd.Timestamp("2011-01-01", tz=tz),
                 pd.Timestamp("2011-01-02", tz=tz),
-                pd.Timestamp("2012-01-01", tz="US/Pacific"),
-                pd.Timestamp("2012-01-02", tz="US/Pacific"),
+                pd.Timestamp("2012-01-01", tz=tz_diff),
+                pd.Timestamp("2012-01-02", tz=tz_diff),
             ],
             dtype=object,
         )
diff --git a/pandas/tests/reshape/merge/test_merge_asof.py b/pandas/tests/reshape/merge/test_merge_asof.py
index 4fc57c14ec4c3..bd364de26a3c4 100644
--- a/pandas/tests/reshape/merge/test_merge_asof.py
+++ b/pandas/tests/reshape/merge/test_merge_asof.py
@@ -2,7 +2,6 @@
 
 import numpy as np
 import pytest
-import pytz
 
 import pandas.util._test_decorators as td
 
@@ -2071,7 +2070,7 @@ def test_tolerance_tz(self, unit):
                     start=to_datetime("2016-01-02"),
                     freq="D",
                     periods=5,
-                    tz=pytz.timezone("UTC"),
+                    tz=datetime.timezone.utc,
                     unit=unit,
                 ),
                 "value1": np.arange(5),
@@ -2083,7 +2082,7 @@ def test_tolerance_tz(self, unit):
                     start=to_datetime("2016-01-01"),
                     freq="D",
                     periods=5,
-                    tz=pytz.timezone("UTC"),
+                    tz=datetime.timezone.utc,
                     unit=unit,
                 ),
                 "value2": list("ABCDE"),
@@ -2097,7 +2096,7 @@ def test_tolerance_tz(self, unit):
                     start=to_datetime("2016-01-02"),
                     freq="D",
                     periods=5,
-                    tz=pytz.timezone("UTC"),
+                    tz=datetime.timezone.utc,
                     unit=unit,
                 ),
                 "value1": np.arange(5),
diff --git a/pandas/tests/scalar/test_nat.py b/pandas/tests/scalar/test_nat.py
index 131be7a77f2e5..b20df43dd49a6 100644
--- a/pandas/tests/scalar/test_nat.py
+++ b/pandas/tests/scalar/test_nat.py
@@ -3,10 +3,10 @@
     timedelta,
 )
 import operator
+import zoneinfo
 
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs.tslibs import iNaT
 from pandas.compat.numpy import np_version_gte1p24p3
@@ -361,7 +361,7 @@ def test_nat_doc_strings(compare):
         (Timestamp("2014-01-01"), "timestamp"),
         (Timestamp("2014-01-01", tz="UTC"), "timestamp"),
         (Timestamp("2014-01-01", tz="US/Eastern"), "timestamp"),
-        (pytz.timezone("Asia/Tokyo").localize(datetime(2014, 1, 1)), "timestamp"),
+        (datetime(2014, 1, 1).astimezone(zoneinfo.ZoneInfo("Asia/Tokyo")), "timestamp"),
     ],
 )
 def test_nat_arithmetic_scalar(op_name, value, val_type):
diff --git a/pandas/tests/scalar/timestamp/methods/test_replace.py b/pandas/tests/scalar/timestamp/methods/test_replace.py
index c5169fdff0cd4..f15ea0e485cae 100644
--- a/pandas/tests/scalar/timestamp/methods/test_replace.py
+++ b/pandas/tests/scalar/timestamp/methods/test_replace.py
@@ -1,9 +1,9 @@
 from datetime import datetime
+import zoneinfo
 
 from dateutil.tz import gettz
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs.tslibs import (
     OutOfBoundsDatetime,
@@ -111,8 +111,8 @@ def test_replace_tzinfo_equiv_tz_localize_none(self):
     @pytest.mark.skipif(WASM, reason="tzset is not available on WASM")
     def test_replace_tzinfo(self):
         # GH#15683
-        dt = datetime(2016, 3, 27, 1)
-        tzinfo = pytz.timezone("CET").localize(dt, is_dst=False).tzinfo
+        dt = datetime(2016, 3, 27, 1, fold=1)
+        tzinfo = dt.astimezone(zoneinfo.ZoneInfo("Europe/Berlin")).tzinfo
 
         result_dt = dt.replace(tzinfo=tzinfo)
         result_pd = Timestamp(dt).replace(tzinfo=tzinfo)
@@ -137,13 +137,16 @@ def test_replace_tzinfo(self):
     @pytest.mark.parametrize(
         "tz, normalize",
         [
-            (pytz.timezone("US/Eastern"), lambda x: x.tzinfo.normalize(x)),
+            ("pytz/US/Eastern", lambda x: x.tzinfo.normalize(x)),
             (gettz("US/Eastern"), lambda x: x),
         ],
     )
     def test_replace_across_dst(self, tz, normalize):
         # GH#18319 check that 1) timezone is correctly normalized and
         # 2) that hour is not incorrectly changed by this normalization
+        if isinstance(tz, str) and tz.startswith("pytz/"):
+            pytz = pytest.importorskip("pytz")
+            tz = pytz.timezone(tz.removeprefix("pytz/"))
         ts_naive = Timestamp("2017-12-03 16:03:30")
         ts_aware = conversion.localize_pydatetime(ts_naive, tz)
 
diff --git a/pandas/tests/scalar/timestamp/methods/test_timestamp_method.py b/pandas/tests/scalar/timestamp/methods/test_timestamp_method.py
index b576317fca8b4..beacaaf04e6b2 100644
--- a/pandas/tests/scalar/timestamp/methods/test_timestamp_method.py
+++ b/pandas/tests/scalar/timestamp/methods/test_timestamp_method.py
@@ -1,8 +1,8 @@
 # NB: This is for the Timestamp.timestamp *method* specifically, not
 # the Timestamp class in general.
+from datetime import timezone
 
 import pytest
-from pytz import utc
 
 from pandas._libs.tslibs import Timestamp
 from pandas.compat import WASM
@@ -18,7 +18,7 @@ def test_timestamp(self, fixed_now_ts):
         # GH#17329
         # tz-naive --> treat it as if it were UTC for purposes of timestamp()
         ts = fixed_now_ts
-        uts = ts.replace(tzinfo=utc)
+        uts = ts.replace(tzinfo=timezone.utc)
         assert ts.timestamp() == uts.timestamp()
 
         tsc = Timestamp("2014-10-11 11:00:01.12345678", tz="US/Central")
diff --git a/pandas/tests/scalar/timestamp/methods/test_to_pydatetime.py b/pandas/tests/scalar/timestamp/methods/test_to_pydatetime.py
index be6ec7dbc24c7..07e57b51a7f1e 100644
--- a/pandas/tests/scalar/timestamp/methods/test_to_pydatetime.py
+++ b/pandas/tests/scalar/timestamp/methods/test_to_pydatetime.py
@@ -3,7 +3,7 @@
     timedelta,
 )
 
-import pytz
+import pytest
 
 from pandas._libs.tslibs.timezones import dateutil_gettz as gettz
 import pandas.util._test_decorators as td
@@ -43,6 +43,7 @@ def test_timestamp_to_pydatetime_dateutil(self):
         assert stamp.tzinfo == dtval.tzinfo
 
     def test_timestamp_to_pydatetime_explicit_pytz(self):
+        pytz = pytest.importorskip("pytz")
         stamp = Timestamp("20090415", tz=pytz.timezone("US/Eastern"))
         dtval = stamp.to_pydatetime()
         assert stamp == dtval
diff --git a/pandas/tests/scalar/timestamp/methods/test_tz_localize.py b/pandas/tests/scalar/timestamp/methods/test_tz_localize.py
index 0786cc58a4f95..90dc8d77608cb 100644
--- a/pandas/tests/scalar/timestamp/methods/test_tz_localize.py
+++ b/pandas/tests/scalar/timestamp/methods/test_tz_localize.py
@@ -1,5 +1,6 @@
 from datetime import timedelta
 import re
+import zoneinfo
 
 from dateutil.tz import gettz
 import pytest
@@ -17,68 +18,56 @@
     Timestamp,
 )
 
-try:
-    from zoneinfo import ZoneInfo
-except ImportError:
-    # Cannot assign to a type
-    ZoneInfo = None  # type: ignore[misc, assignment]
-
 
 class TestTimestampTZLocalize:
     @pytest.mark.skip_ubsan
     def test_tz_localize_pushes_out_of_bounds(self):
         # GH#12677
         # tz_localize that pushes away from the boundary is OK
+        pytz = pytest.importorskip("pytz")
         msg = (
             f"Converting {Timestamp.min.strftime('%Y-%m-%d %H:%M:%S')} "
             f"underflows past {Timestamp.min}"
         )
-        pac = Timestamp.min.tz_localize("US/Pacific")
+        pac = Timestamp.min.tz_localize(pytz.timezone("US/Pacific"))
         assert pac._value > Timestamp.min._value
         pac.tz_convert("Asia/Tokyo")  # tz_convert doesn't change value
         with pytest.raises(OutOfBoundsDatetime, match=msg):
-            Timestamp.min.tz_localize("Asia/Tokyo")
+            Timestamp.min.tz_localize(pytz.timezone("Asia/Tokyo"))
 
         # tz_localize that pushes away from the boundary is OK
         msg = (
             f"Converting {Timestamp.max.strftime('%Y-%m-%d %H:%M:%S')} "
             f"overflows past {Timestamp.max}"
         )
-        tokyo = Timestamp.max.tz_localize("Asia/Tokyo")
+        tokyo = Timestamp.max.tz_localize(pytz.timezone("Asia/Tokyo"))
         assert tokyo._value < Timestamp.max._value
         tokyo.tz_convert("US/Pacific")  # tz_convert doesn't change value
         with pytest.raises(OutOfBoundsDatetime, match=msg):
-            Timestamp.max.tz_localize("US/Pacific")
+            Timestamp.max.tz_localize(pytz.timezone("US/Pacific"))
 
-    def test_tz_localize_ambiguous_bool(self, unit):
+    @pytest.mark.parametrize(
+        "tz",
+        [zoneinfo.ZoneInfo("US/Central"), "dateutil/US/Central", "pytz/US/Central"],
+    )
+    def test_tz_localize_ambiguous_bool(self, unit, tz):
         # make sure that we are correctly accepting bool values as ambiguous
         # GH#14402
+        if isinstance(tz, str) and tz.startswith("pytz/"):
+            tz = pytz.timezone(tz.removeprefix("pytz/"))
         ts = Timestamp("2015-11-01 01:00:03").as_unit(unit)
-        expected0 = Timestamp("2015-11-01 01:00:03-0500", tz="US/Central")
-        expected1 = Timestamp("2015-11-01 01:00:03-0600", tz="US/Central")
+        expected0 = Timestamp("2015-11-01 01:00:03-0500", tz=tz)
+        expected1 = Timestamp("2015-11-01 01:00:03-0600", tz=tz)
 
         msg = "Cannot infer dst time from 2015-11-01 01:00:03"
         with pytest.raises(pytz.AmbiguousTimeError, match=msg):
-            ts.tz_localize("US/Central")
+            ts.tz_localize(tz)
 
-        with pytest.raises(pytz.AmbiguousTimeError, match=msg):
-            ts.tz_localize("dateutil/US/Central")
-
-        if ZoneInfo is not None:
-            try:
-                tz = ZoneInfo("US/Central")
-            except KeyError:
-                # no tzdata
-                pass
-            else:
-                with pytest.raises(pytz.AmbiguousTimeError, match=msg):
-                    ts.tz_localize(tz)
-
-        result = ts.tz_localize("US/Central", ambiguous=True)
+        result = ts.tz_localize(tz, ambiguous=True)
         assert result == expected0
         assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
 
-        result = ts.tz_localize("US/Central", ambiguous=False)
+        result = ts.tz_localize(tz, ambiguous=False)
         assert result == expected1
         assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value
 
@@ -205,9 +194,10 @@ def test_tz_localize_roundtrip(self, stamp, tz_aware_fixture):
     def test_tz_localize_ambiguous_compat(self):
         # validate that pytz and dateutil are compat for dst
         # when the transition happens
+        pytz = pytest.importorskip("pytz")
         naive = Timestamp("2013-10-27 01:00:00")
 
-        pytz_zone = "Europe/London"
+        pytz_zone = pytz.timezone("Europe/London")
         dateutil_zone = "dateutil/Europe/London"
         result_pytz = naive.tz_localize(pytz_zone, ambiguous=False)
         result_dateutil = naive.tz_localize(dateutil_zone, ambiguous=False)
@@ -236,13 +226,16 @@ def test_tz_localize_ambiguous_compat(self):
     @pytest.mark.parametrize(
         "tz",
         [
-            pytz.timezone("US/Eastern"),
+            "pytz/US/Eastern",
             gettz("US/Eastern"),
-            "US/Eastern",
+            zoneinfo.ZoneInfo("US/Eastern"),
             "dateutil/US/Eastern",
         ],
     )
     def test_timestamp_tz_localize(self, tz):
+        if isinstance(tz, str) and tz.startswith("pytz/"):
+            pytz = pytest.importorskip("pytz")
+            tz = pytz.timezone(tz.removeprefix("pytz/"))
         stamp = Timestamp("3/11/2012 04:00")
 
         result = stamp.tz_localize(tz)
diff --git a/pandas/tests/scalar/timestamp/test_arithmetic.py b/pandas/tests/scalar/timestamp/test_arithmetic.py
index 2d58513989a66..7aa6c6c0496a9 100644
--- a/pandas/tests/scalar/timestamp/test_arithmetic.py
+++ b/pandas/tests/scalar/timestamp/test_arithmetic.py
@@ -7,7 +7,6 @@
 from dateutil.tz import gettz
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs.tslibs import (
     OutOfBoundsDatetime,
@@ -294,7 +293,7 @@ def test_subtract_different_utc_objects(self, utc_fixture, utc_fixture2):
     @pytest.mark.parametrize(
         "tz",
         [
-            pytz.timezone("US/Eastern"),
+            "pytz/US/Eastern",
             gettz("US/Eastern"),
             "US/Eastern",
             "dateutil/US/Eastern",
@@ -302,7 +301,9 @@ def test_subtract_different_utc_objects(self, utc_fixture, utc_fixture2):
     )
     def test_timestamp_add_timedelta_push_over_dst_boundary(self, tz):
         # GH#1389
-
+        if isinstance(tz, str) and tz.startswith("pytz/"):
+            pytz = pytest.importorskip("pytz")
+            tz = pytz.timezone(tz.removeprefix("pytz/"))
         # 4 hours before DST transition
         stamp = Timestamp("3/10/2012 22:00", tz=tz)
 
diff --git a/pandas/tests/scalar/timestamp/test_constructors.py b/pandas/tests/scalar/timestamp/test_constructors.py
index 4ebdea3733484..f213fd8eb61ef 100644
--- a/pandas/tests/scalar/timestamp/test_constructors.py
+++ b/pandas/tests/scalar/timestamp/test_constructors.py
@@ -123,6 +123,7 @@ def test_timestamp_constructor_pytz_fold_raise(self):
         # Test for GH#25057
         # pytz doesn't support fold. Check that we raise
         # if fold is passed with pytz
+        pytz = pytest.importorskip("pytz")
         msg = "pytz timezones do not support fold. Please use dateutil timezones."
         tz = pytz.timezone("Europe/London")
         with pytest.raises(ValueError, match=msg):
@@ -160,15 +161,13 @@ def test_timestamp_constructor_retain_fold(self, tz, fold):
         expected = fold
         assert result == expected
 
-    try:
-        _tzs = [
+    @pytest.mark.parametrize(
+        "tz",
+        [
             "dateutil/Europe/London",
             zoneinfo.ZoneInfo("Europe/London"),
-        ]
-    except zoneinfo.ZoneInfoNotFoundError:
-        _tzs = ["dateutil/Europe/London"]
-
-    @pytest.mark.parametrize("tz", _tzs)
+        ],
+    )
     @pytest.mark.parametrize(
         "ts_input,fold_out",
         [
@@ -565,11 +564,11 @@ def test_constructor(self):
         timezones = [
             (None, 0),
             ("UTC", 0),
-            (pytz.utc, 0),
+            (timezone.utc, 0),
             ("Asia/Tokyo", 9),
             ("US/Eastern", -4),
             ("dateutil/US/Pacific", -7),
-            (pytz.FixedOffset(-180), -3),
+            (timezone(timedelta(hours=-3)), -3),
             (dateutil.tz.tzoffset(None, 18000), 5),
         ]
 
@@ -622,11 +621,11 @@ def test_constructor_with_stringoffset(self):
 
         timezones = [
             ("UTC", 0),
-            (pytz.utc, 0),
+            (timezone.utc, 0),
             ("Asia/Tokyo", 9),
             ("US/Eastern", -4),
             ("dateutil/US/Pacific", -7),
-            (pytz.FixedOffset(-180), -3),
+            (timezone(timedelta(hours=-3)), -3),
             (dateutil.tz.tzoffset(None, 18000), 5),
         ]
 
@@ -706,7 +705,7 @@ def test_constructor_invalid_tz(self):
 
         msg = "at most one of"
         with pytest.raises(ValueError, match=msg):
-            Timestamp("2017-10-22", tzinfo=pytz.utc, tz="UTC")
+            Timestamp("2017-10-22", tzinfo=timezone.utc, tz="UTC")
 
         msg = "Cannot pass a date attribute keyword argument when passing a date string"
         with pytest.raises(ValueError, match=msg):
@@ -719,11 +718,11 @@ def test_constructor_tz_or_tzinfo(self):
         # GH#17943, GH#17690, GH#5168
         stamps = [
             Timestamp(year=2017, month=10, day=22, tz="UTC"),
-            Timestamp(year=2017, month=10, day=22, tzinfo=pytz.utc),
-            Timestamp(year=2017, month=10, day=22, tz=pytz.utc),
-            Timestamp(datetime(2017, 10, 22), tzinfo=pytz.utc),
+            Timestamp(year=2017, month=10, day=22, tzinfo=timezone.utc),
+            Timestamp(year=2017, month=10, day=22, tz=timezone.utc),
+            Timestamp(datetime(2017, 10, 22), tzinfo=timezone.utc),
             Timestamp(datetime(2017, 10, 22), tz="UTC"),
-            Timestamp(datetime(2017, 10, 22), tz=pytz.utc),
+            Timestamp(datetime(2017, 10, 22), tz=timezone.utc),
         ]
         assert all(ts == stamps[0] for ts in stamps)
 
@@ -898,13 +897,13 @@ def test_construct_timestamp_near_dst(self, offset):
     def test_construct_with_different_string_format(self, arg):
         # GH 12064
         result = Timestamp(arg)
-        expected = Timestamp(datetime(2013, 1, 1), tz=pytz.FixedOffset(540))
+        expected = Timestamp(datetime(2013, 1, 1), tz=timezone(timedelta(hours=9)))
         assert result == expected
 
     @pytest.mark.parametrize("box", [datetime, Timestamp])
     def test_raise_tz_and_tzinfo_in_datetime_input(self, box):
         # GH 23579
-        kwargs = {"year": 2018, "month": 1, "day": 1, "tzinfo": pytz.utc}
+        kwargs = {"year": 2018, "month": 1, "day": 1, "tzinfo": timezone.utc}
         msg = "Cannot pass a datetime or Timestamp"
         with pytest.raises(ValueError, match=msg):
             Timestamp(box(**kwargs), tz="US/Pacific")
@@ -912,7 +911,7 @@ def test_raise_tz_and_tzinfo_in_datetime_input(self, box):
         with pytest.raises(ValueError, match=msg):
             Timestamp(box(**kwargs), tzinfo=pytz.timezone("US/Pacific"))
 
-    def test_dont_convert_dateutil_utc_to_pytz_utc(self):
+    def test_dont_convert_dateutil_utc_to_default_utc(self):
         result = Timestamp(datetime(2018, 1, 1), tz=tzutc())
         expected = Timestamp(datetime(2018, 1, 1)).tz_localize(tzutc())
         assert result == expected
@@ -996,7 +995,7 @@ def test_timestamp_constructor_near_dst_boundary(self):
     @pytest.mark.parametrize(
         "tz",
         [
-            pytz.timezone("US/Eastern"),
+            "pytz/US/Eastern",
             gettz("US/Eastern"),
             "US/Eastern",
             "dateutil/US/Eastern",
@@ -1005,7 +1004,9 @@ def test_timestamp_constructor_near_dst_boundary(self):
     def test_timestamp_constructed_by_date_and_tz(self, tz):
         # GH#2993, Timestamp cannot be constructed by datetime.date
         # and tz correctly
-
+        if isinstance(tz, str) and tz.startswith("pytz/"):
+            pytz = pytest.importorskip("pytz")
+            tz = pytz.timezone(tz.removeprefix("pytz/"))
         result = Timestamp(date(2012, 3, 11), tz=tz)
 
         expected = Timestamp("3/11/2012", tz=tz)
diff --git a/pandas/tests/scalar/timestamp/test_formats.py b/pandas/tests/scalar/timestamp/test_formats.py
index 44db1187850c9..7b20f0a17556d 100644
--- a/pandas/tests/scalar/timestamp/test_formats.py
+++ b/pandas/tests/scalar/timestamp/test_formats.py
@@ -1,9 +1,11 @@
-from datetime import datetime
+from datetime import (
+    datetime,
+    timezone,
+)
 import pprint
 
 import dateutil.tz
 import pytest
-import pytz  # a test below uses pytz but only inside a `eval` call
 
 from pandas.compat import WASM
 
@@ -181,14 +183,14 @@ def test_repr_matches_pydatetime_no_tz(self):
         ts_nanos_micros = Timestamp(1200)
         assert str(ts_nanos_micros) == "1970-01-01 00:00:00.000001200"
 
-    def test_repr_matches_pydatetime_tz_pytz(self):
-        dt_date = datetime(2013, 1, 2, tzinfo=pytz.utc)
+    def test_repr_matches_pydatetime_tz_stdlib(self):
+        dt_date = datetime(2013, 1, 2, tzinfo=timezone.utc)
         assert str(dt_date) == str(Timestamp(dt_date))
 
-        dt_datetime = datetime(2013, 1, 2, 12, 1, 3, tzinfo=pytz.utc)
+        dt_datetime = datetime(2013, 1, 2, 12, 1, 3, tzinfo=timezone.utc)
         assert str(dt_datetime) == str(Timestamp(dt_datetime))
 
-        dt_datetime_us = datetime(2013, 1, 2, 12, 1, 3, 45, tzinfo=pytz.utc)
+        dt_datetime_us = datetime(2013, 1, 2, 12, 1, 3, 45, tzinfo=timezone.utc)
         assert str(dt_datetime_us) == str(Timestamp(dt_datetime_us))
 
     def test_repr_matches_pydatetime_tz_dateutil(self):
diff --git a/pandas/tests/scalar/timestamp/test_timestamp.py b/pandas/tests/scalar/timestamp/test_timestamp.py
index 79fd285073983..38d0ddfbc13bd 100644
--- a/pandas/tests/scalar/timestamp/test_timestamp.py
+++ b/pandas/tests/scalar/timestamp/test_timestamp.py
@@ -9,6 +9,7 @@
 import locale
 import time
 import unicodedata
+import zoneinfo
 
 from dateutil.tz import (
     tzlocal,
@@ -20,8 +21,6 @@
 )
 import numpy as np
 import pytest
-import pytz
-from pytz import utc
 
 from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
 from pandas._libs.tslibs.timezones import (
@@ -259,7 +258,7 @@ def test_dow_parametric(self, ts, sign):
 
 
 class TestTimestamp:
-    @pytest.mark.parametrize("tz", [None, pytz.timezone("US/Pacific")])
+    @pytest.mark.parametrize("tz", [None, zoneinfo.ZoneInfo("US/Pacific")])
     def test_disallow_setting_tz(self, tz):
         # GH#3746
         ts = Timestamp("2010")
@@ -311,7 +310,7 @@ def compare(x, y):
             assert int((Timestamp(x)._value - Timestamp(y)._value) / 1e9) == 0
 
         compare(Timestamp.now(), datetime.now())
-        compare(Timestamp.now("UTC"), datetime.now(pytz.timezone("UTC")))
+        compare(Timestamp.now("UTC"), datetime.now(timezone.utc))
         compare(Timestamp.now("UTC"), datetime.now(tzutc()))
         msg = "Timestamp.utcnow is deprecated"
         with tm.assert_produces_warning(FutureWarning, match=msg):
@@ -329,12 +328,12 @@ def compare(x, y):
         compare(
             # Support tz kwarg in Timestamp.fromtimestamp
             Timestamp.fromtimestamp(current_time, "UTC"),
-            datetime.fromtimestamp(current_time, utc),
+            datetime.fromtimestamp(current_time, timezone.utc),
         )
         compare(
             # Support tz kwarg in Timestamp.fromtimestamp
             Timestamp.fromtimestamp(current_time, tz="UTC"),
-            datetime.fromtimestamp(current_time, utc),
+            datetime.fromtimestamp(current_time, timezone.utc),
         )
 
         date_component = datetime.now(timezone.utc)
@@ -585,9 +584,9 @@ def test_month_name(self, dt64, ts):
         assert ts.month_name() == alt.month_name()
 
     def test_tz_convert(self, ts):
-        ts = Timestamp._from_value_and_reso(ts._value, ts._creso, utc)
+        ts = Timestamp._from_value_and_reso(ts._value, ts._creso, timezone.utc)
 
-        tz = pytz.timezone("US/Pacific")
+        tz = zoneinfo.ZoneInfo("US/Pacific")
         result = ts.tz_convert(tz)
 
         assert isinstance(result, Timestamp)
diff --git a/pandas/tests/series/indexing/test_datetime.py b/pandas/tests/series/indexing/test_datetime.py
index 3b41c8ee463d8..97cafc33611ed 100644
--- a/pandas/tests/series/indexing/test_datetime.py
+++ b/pandas/tests/series/indexing/test_datetime.py
@@ -14,7 +14,6 @@
 )
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs import index as libindex
 
@@ -63,6 +62,7 @@ def test_fancy_setitem():
 @pytest.mark.parametrize("tz_source", ["pytz", "dateutil"])
 def test_getitem_setitem_datetime_tz(tz_source):
     if tz_source == "pytz":
+        pytz = pytest.importorskip(tz_source)
         tzget = pytz.timezone
     else:
         # handle special case for utc in dateutil
diff --git a/pandas/tests/series/methods/test_fillna.py b/pandas/tests/series/methods/test_fillna.py
index c10bb8278a3d1..e1c771ec6e658 100644
--- a/pandas/tests/series/methods/test_fillna.py
+++ b/pandas/tests/series/methods/test_fillna.py
@@ -6,7 +6,6 @@
 
 import numpy as np
 import pytest
-import pytz
 
 from pandas import (
     Categorical,
@@ -861,7 +860,7 @@ def test_fillna_bug(self):
 
     def test_ffill_mixed_dtypes_without_missing_data(self):
         # GH#14956
-        series = Series([datetime(2015, 1, 1, tzinfo=pytz.utc), 1])
+        series = Series([datetime(2015, 1, 1, tzinfo=timezone.utc), 1])
         result = series.ffill()
         tm.assert_series_equal(series, result)
 
@@ -923,16 +922,16 @@ def test_datetime64tz_fillna_round_issue(self):
         # GH#14872
 
         data = Series(
-            [NaT, NaT, datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=pytz.utc)]
+            [NaT, NaT, datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=timezone.utc)]
         )
 
         filled = data.bfill()
 
         expected = Series(
             [
-                datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=pytz.utc),
-                datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=pytz.utc),
-                datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=pytz.utc),
+                datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=timezone.utc),
+                datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=timezone.utc),
+                datetime(2016, 12, 12, 22, 24, 6, 100001, tzinfo=timezone.utc),
             ]
         )
 
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index cbbd018720bad..4f5b7f884ce12 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -10,11 +10,11 @@
 )
 from decimal import Decimal
 import locale
+import zoneinfo
 
 from dateutil.parser import parse
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs import tslib
 from pandas._libs.tslibs import (
@@ -432,9 +432,11 @@ def test_to_datetime_format_weeks(self, value, fmt, expected, cache):
                 ["2010-01-01 12:00:00 Z", "2010-01-01 12:00:00 Z"],
                 [
                     Timestamp(
-                        "2010-01-01 12:00:00", tzinfo=pytz.FixedOffset(0)
-                    ),  # pytz coerces to UTC
-                    Timestamp("2010-01-01 12:00:00", tzinfo=pytz.FixedOffset(0)),
+                        "2010-01-01 12:00:00", tzinfo=timezone(timedelta(minutes=0))
+                    ),
+                    Timestamp(
+                        "2010-01-01 12:00:00", tzinfo=timezone(timedelta(minutes=0))
+                    ),
                 ],
             ],
         ],
@@ -1169,6 +1171,7 @@ def test_to_datetime_different_offsets_removed(self, cache):
 
     def test_to_datetime_tz_pytz(self, cache):
         # see gh-8260
+        pytz = pytest.importorskip("pytz")
         us_eastern = pytz.timezone("US/Eastern")
         arr = np.array(
             [
@@ -1699,7 +1702,9 @@ def test_to_datetime_fixed_offset(self):
             ["2020-10-26 00:00:00+06:00", Timestamp("2018-01-01", tz="US/Pacific")],
             [
                 "2020-10-26 00:00:00+06:00",
-                datetime(2020, 1, 1, 18, tzinfo=pytz.timezone("Australia/Melbourne")),
+                datetime(2020, 1, 1, 18).astimezone(
+                    zoneinfo.ZoneInfo("Australia/Melbourne")
+                ),
             ],
         ],
     )
@@ -2351,7 +2356,7 @@ def test_to_datetime_iso8601_non_padded(self, input, format):
     )
     def test_to_datetime_iso8601_with_timezone_valid(self, input, format):
         # https://github.com/pandas-dev/pandas/issues/12649
-        expected = Timestamp(2020, 1, 1, tzinfo=pytz.UTC)
+        expected = Timestamp(2020, 1, 1, tzinfo=timezone.utc)
         result = to_datetime(input, format=format)
         assert result == expected
 
@@ -2778,7 +2783,7 @@ def test_infer_datetime_format_zero_tz(self, ts, zero_tz):
         # GH 41047
         ser = Series([ts + zero_tz])
         result = to_datetime(ser)
-        tz = pytz.utc if zero_tz == "Z" else None
+        tz = timezone.utc if zero_tz == "Z" else None
         expected = Series([Timestamp(ts, tz=tz)])
         tm.assert_series_equal(result, expected)
 
@@ -3213,7 +3218,7 @@ def test_invalid_origins(self, origin, exc, units):
     def test_invalid_origins_tzinfo(self):
         # GH16842
         with pytest.raises(ValueError, match="must be tz-naive"):
-            to_datetime(1, unit="D", origin=datetime(2000, 1, 1, tzinfo=pytz.utc))
+            to_datetime(1, unit="D", origin=datetime(2000, 1, 1, tzinfo=timezone.utc))
 
     def test_incorrect_value_exception(self):
         # GH47495
diff --git a/pandas/tests/tseries/holiday/test_holiday.py b/pandas/tests/tseries/holiday/test_holiday.py
index 08f4a1250392e..ffe6ff0b51bcf 100644
--- a/pandas/tests/tseries/holiday/test_holiday.py
+++ b/pandas/tests/tseries/holiday/test_holiday.py
@@ -1,7 +1,9 @@
-from datetime import datetime
+from datetime import (
+    datetime,
+    timezone,
+)
 
 import pytest
-from pytz import utc
 
 from pandas import (
     DatetimeIndex,
@@ -128,9 +130,9 @@ def test_holiday_dates(holiday, start_date, end_date, expected):
     # Verify that timezone info is preserved.
     assert list(
         holiday.dates(
-            utc.localize(Timestamp(start_date)), utc.localize(Timestamp(end_date))
+            Timestamp(start_date, tz=timezone.utc), Timestamp(end_date, tz=timezone.utc)
         )
-    ) == [utc.localize(dt) for dt in expected]
+    ) == [dt.replace(tzinfo=timezone.utc) for dt in expected]
 
 
 @pytest.mark.parametrize(
@@ -194,8 +196,10 @@ def test_holidays_within_dates(holiday, start, expected):
 
     # Verify that timezone info is preserved.
     assert list(
-        holiday.dates(utc.localize(Timestamp(start)), utc.localize(Timestamp(start)))
-    ) == [utc.localize(dt) for dt in expected]
+        holiday.dates(
+            Timestamp(start, tz=timezone.utc), Timestamp(start, tz=timezone.utc)
+        )
+    ) == [dt.replace(tzinfo=timezone.utc) for dt in expected]
 
 
 @pytest.mark.parametrize(
diff --git a/pandas/tests/tseries/offsets/test_dst.py b/pandas/tests/tseries/offsets/test_dst.py
index 8ff80536fc69e..dfdc69c0fe18e 100644
--- a/pandas/tests/tseries/offsets/test_dst.py
+++ b/pandas/tests/tseries/offsets/test_dst.py
@@ -5,7 +5,6 @@
 from datetime import timedelta
 
 import pytest
-import pytz
 
 from pandas._libs.tslibs import Timestamp
 from pandas._libs.tslibs.offsets import (
@@ -33,10 +32,8 @@
 
 from pandas import DatetimeIndex
 import pandas._testing as tm
-from pandas.util.version import Version
 
-# error: Module has no attribute "__version__"
-pytz_version = Version(pytz.__version__)  # type: ignore[attr-defined]
+pytz = pytest.importorskip("pytz")
 
 
 def get_utc_offset_hours(ts):
@@ -52,7 +49,10 @@ class TestDST:
 
     # test both basic names and dateutil timezones
     timezone_utc_offsets = {
-        "US/Eastern": {"utc_offset_daylight": -4, "utc_offset_standard": -5},
+        pytz.timezone("US/Eastern"): {
+            "utc_offset_daylight": -4,
+            "utc_offset_standard": -5,
+        },
         "dateutil/US/Pacific": {"utc_offset_daylight": -7, "utc_offset_standard": -8},
     }
     valid_date_offsets_singular = [
@@ -96,7 +96,10 @@ def _test_offset(
         if (
             offset_name in ["hour", "minute", "second", "microsecond"]
             and offset_n == 1
-            and tstart == Timestamp("2013-11-03 01:59:59.999999-0500", tz="US/Eastern")
+            and tstart
+            == Timestamp(
+                "2013-11-03 01:59:59.999999-0500", tz=pytz.timezone("US/Eastern")
+            )
         ):
             # This addition results in an ambiguous wall time
             err_msg = {
@@ -147,7 +150,9 @@ def _test_offset(
             assert datepart_offset == offset.kwds[offset_name]
         else:
             # the offset should be the same as if it was done in UTC
-            assert t == (tstart.tz_convert("UTC") + offset).tz_convert("US/Pacific")
+            assert t == (tstart.tz_convert("UTC") + offset).tz_convert(
+                pytz.timezone("US/Pacific")
+            )
 
     def _make_timestamp(self, string, hrs_offset, tz):
         if hrs_offset >= 0:
@@ -224,16 +229,6 @@ def test_all_offset_classes(self, tup):
 @pytest.mark.parametrize(
     "original_dt, target_dt, offset, tz",
     [
-        pytest.param(
-            Timestamp("1900-01-01"),
-            Timestamp("1905-07-01"),
-            MonthBegin(66),
-            "Africa/Lagos",
-            marks=pytest.mark.xfail(
-                pytz_version < Version("2020.5") or pytz_version == Version("2022.2"),
-                reason="GH#41906: pytz utc transition dates changed",
-            ),
-        ),
         (
             Timestamp("2021-10-01 01:15"),
             Timestamp("2021-10-31 01:15"),
@@ -263,7 +258,7 @@ def test_all_offset_classes(self, tup):
 def test_nontick_offset_with_ambiguous_time_error(original_dt, target_dt, offset, tz):
     # .apply for non-Tick offsets throws AmbiguousTimeError when the target dt
     # is dst-ambiguous
-    localized_dt = original_dt.tz_localize(tz)
+    localized_dt = original_dt.tz_localize(pytz.timezone(tz))
 
     msg = f"Cannot infer dst time from {target_dt}, try using the 'ambiguous' argument"
     with pytest.raises(pytz.AmbiguousTimeError, match=msg):
diff --git a/pandas/tests/tslibs/test_conversion.py b/pandas/tests/tslibs/test_conversion.py
index 6a0b86cbd03ee..f62910b5e1f1c 100644
--- a/pandas/tests/tslibs/test_conversion.py
+++ b/pandas/tests/tslibs/test_conversion.py
@@ -1,8 +1,10 @@
-from datetime import datetime
+from datetime import (
+    datetime,
+    timezone,
+)
 
 import numpy as np
 import pytest
-from pytz import UTC
 
 from pandas._libs.tslibs import (
     OutOfBoundsTimedelta,
@@ -55,7 +57,7 @@ def _compare_local_to_utc(tz_didx, naive_didx):
 def test_tz_localize_to_utc_copies():
     # GH#46460
     arr = np.arange(5, dtype="i8")
-    result = tz_convert_from_utc(arr, tz=UTC)
+    result = tz_convert_from_utc(arr, tz=timezone.utc)
     tm.assert_numpy_array_equal(result, arr)
     assert not np.shares_memory(arr, result)
 
@@ -100,7 +102,7 @@ def test_tz_convert_readonly():
     # GH#35530
     arr = np.array([0], dtype=np.int64)
     arr.setflags(write=False)
-    result = tz_convert_from_utc(arr, UTC)
+    result = tz_convert_from_utc(arr, timezone.utc)
     tm.assert_numpy_array_equal(result, arr)
 
 
@@ -141,14 +143,18 @@ class SubDatetime(datetime):
     "dt, expected",
     [
         pytest.param(
-            Timestamp("2000-01-01"), Timestamp("2000-01-01", tz=UTC), id="timestamp"
+            Timestamp("2000-01-01"),
+            Timestamp("2000-01-01", tz=timezone.utc),
+            id="timestamp",
         ),
         pytest.param(
-            datetime(2000, 1, 1), datetime(2000, 1, 1, tzinfo=UTC), id="datetime"
+            datetime(2000, 1, 1),
+            datetime(2000, 1, 1, tzinfo=timezone.utc),
+            id="datetime",
         ),
         pytest.param(
             SubDatetime(2000, 1, 1),
-            SubDatetime(2000, 1, 1, tzinfo=UTC),
+            SubDatetime(2000, 1, 1, tzinfo=timezone.utc),
             id="subclassed_datetime",
         ),
     ],
@@ -157,5 +163,5 @@ def test_localize_pydatetime_dt_types(dt, expected):
     # GH 25851
     # ensure that subclassed datetime works with
     # localize_pydatetime
-    result = conversion.localize_pydatetime(dt, UTC)
+    result = conversion.localize_pydatetime(dt, timezone.utc)
     assert result == expected
diff --git a/pandas/tests/tslibs/test_resolution.py b/pandas/tests/tslibs/test_resolution.py
index e9da6b3cf991c..49b87c055dc69 100644
--- a/pandas/tests/tslibs/test_resolution.py
+++ b/pandas/tests/tslibs/test_resolution.py
@@ -1,6 +1,7 @@
+import datetime
+
 import numpy as np
 import pytest
-import pytz
 
 from pandas._libs.tslibs import (
     Resolution,
@@ -23,7 +24,7 @@ def test_get_resolution_non_nano_data():
     res = get_resolution(arr, None, NpyDatetimeUnit.NPY_FR_us.value)
     assert res == Resolution.RESO_US
 
-    res = get_resolution(arr, pytz.UTC, NpyDatetimeUnit.NPY_FR_us.value)
+    res = get_resolution(arr, datetime.timezone.utc, NpyDatetimeUnit.NPY_FR_us.value)
     assert res == Resolution.RESO_US
 
 
diff --git a/pandas/tests/tslibs/test_timezones.py b/pandas/tests/tslibs/test_timezones.py
index 28e4889983fb9..8dd7060f21d59 100644
--- a/pandas/tests/tslibs/test_timezones.py
+++ b/pandas/tests/tslibs/test_timezones.py
@@ -6,7 +6,6 @@
 
 import dateutil.tz
 import pytest
-import pytz
 
 from pandas._libs.tslibs import (
     conversion,
@@ -22,10 +21,11 @@ def test_is_utc(utc_fixture):
     assert timezones.is_utc(tz)
 
 
-@pytest.mark.parametrize("tz_name", list(pytz.common_timezones))
-def test_cache_keys_are_distinct_for_pytz_vs_dateutil(tz_name):
-    tz_p = timezones.maybe_get_tz(tz_name)
-    tz_d = timezones.maybe_get_tz("dateutil/" + tz_name)
+def test_cache_keys_are_distinct_for_pytz_vs_dateutil():
+    pytz = pytest.importorskip("pytz")
+    for tz_name in pytz.common_timezones:
+        tz_p = timezones.maybe_get_tz(tz_name)
+        tz_d = timezones.maybe_get_tz("dateutil/" + tz_name)
 
     if tz_d is None:
         pytest.skip(tz_name + ": dateutil does not know about this one")
@@ -76,12 +76,15 @@ def test_tz_compare_utc(utc_fixture, utc_fixture2):
 
 @pytest.fixture(
     params=[
-        (pytz.timezone("US/Eastern"), lambda tz, x: tz.localize(x)),
+        ("pytz/US/Eastern", lambda tz, x: tz.localize(x)),
         (dateutil.tz.gettz("US/Eastern"), lambda tz, x: x.replace(tzinfo=tz)),
     ]
 )
 def infer_setup(request):
     eastern, localize = request.param
+    if isinstance(eastern, str) and eastern.startswith("pytz/"):
+        pytz = pytest.importorskip("pytz")
+        eastern = pytz.timezone(eastern.removeprefix("pytz/"))
 
     start_naive = datetime(2001, 1, 1)
     end_naive = datetime(2009, 1, 1)
@@ -111,10 +114,10 @@ def test_infer_tz_compat(infer_setup):
 
 def test_infer_tz_utc_localize(infer_setup):
     _, _, start, end, start_naive, end_naive = infer_setup
-    utc = pytz.utc
+    utc = timezone.utc
 
-    start = utc.localize(start_naive)
-    end = utc.localize(end_naive)
+    start = start_naive.astimezone(utc)
+    end = end_naive.astimezone(utc)
 
     assert timezones.infer_tzinfo(start, end) is utc
 
@@ -124,8 +127,8 @@ def test_infer_tz_mismatch(infer_setup, ordered):
     eastern, _, _, _, start_naive, end_naive = infer_setup
     msg = "Inputs must both have the same timezone"
 
-    utc = pytz.utc
-    start = utc.localize(start_naive)
+    utc = timezone.utc
+    start = start_naive.astimezone(utc)
     end = conversion.localize_pydatetime(end_naive, eastern)
 
     args = (start, end) if ordered else (end, start)
@@ -139,7 +142,7 @@ def test_maybe_get_tz_invalid_types():
         timezones.maybe_get_tz(44.0)
 
     with pytest.raises(TypeError, match="<class 'module'>"):
-        timezones.maybe_get_tz(pytz)
+        timezones.maybe_get_tz(pytest)
 
     msg = "<class 'pandas._libs.tslibs.timestamps.Timestamp'>"
     with pytest.raises(TypeError, match=msg):